//Methods /// <summary> /// Updates the statistics. /// </summary> /// <param name="readoutData">The computed readout data.</param> /// <param name="idealValues">The ideal data.</param> public void Update(ReadoutLayer.ReadoutData readoutData, double[] idealValues) { ReadoutLayer.ReadoutData.OneTakesAllGroupData groupData = readoutData.GetOneTakesAllGroupData(Name); //Determine correct member int memberCorrectIndex = 0; double idealMaxP = double.MinValue; double[] memberRawProbabilities = new double[groupData.MemberReadoutUnitIndexes.Length]; for (int i = 0; i < groupData.MemberReadoutUnitIndexes.Length; i++) { memberRawProbabilities[i] = readoutData.ReadoutUnitDataCollection[groupData.MemberReadoutUnitIndexes[i]].RawNrmDataValue; if (idealValues[groupData.MemberReadoutUnitIndexes[i]] > idealMaxP) { memberCorrectIndex = i; idealMaxP = idealValues[groupData.MemberReadoutUnitIndexes[i]]; } } //Group error double err = (groupData.MemberWinningGroupIndex == memberCorrectIndex ? 0d : 1d); GroupErrorStat.AddSample(err); //Member errors MemberErrorStatCollection[memberCorrectIndex].Update(memberRawProbabilities, groupData.MemberProbabilities, groupData.MemberWinningGroupIndex ); return; }
//Methods /// <summary> /// Updates error statistics /// </summary> /// <param name="readoutData">Computed readout data</param> /// <param name="idealValues">Ideal values</param> public void Update(ReadoutLayer.ReadoutData readoutData, double[] idealValues) { //Determine correct member int memberCorrectIndex = 0; double idealMaxP = -1; int[] memberReadoutUnitIndexes = readoutData.OneWinnerDataCollection[Name].MemberReadoutUnitIndexes; for (int i = 0; i < memberReadoutUnitIndexes.Length; i++) { if (idealValues[memberReadoutUnitIndexes[i]] > idealMaxP) { memberCorrectIndex = i; idealMaxP = idealValues[memberReadoutUnitIndexes[i]]; } } //Group error double err = (readoutData.OneWinnerDataCollection[Name].MemberWinningIndex == memberCorrectIndex ? 0d : 1d); GroupErrorStat.AddSampleValue(err); //Member errors MemberErrorStatCollection[memberCorrectIndex].Update(readoutData.OneWinnerDataCollection[Name].MemberProbabilities, readoutData.OneWinnerDataCollection[Name].MemberWinningIndex ); return; }
/// <summary> /// Runs the example code. /// </summary> public void Run() { //Create Examples directory Directory.CreateDirectory(".\\Examples"); //Create StateMachine configuration StateMachineSettings stateMachineCfg = CreateStateMachineCfg(); //Store StateMachine xml configuration string xmlConfig = stateMachineCfg.GetXml(true).ToString(); string configFileName = ".\\Examples\\TTOOForecastFromScratchSMConfig.xml"; using (StreamWriter writer = new StreamWriter(File.Create(configFileName))) { writer.Write(xmlConfig); } //Display StateMachine xml configuration _log.Write("StateMachine configuration xml:"); _log.Write("-------------------------------"); _log.Write(xmlConfig); _log.Write(string.Empty); _log.Write("Pres Enter to continue (StateMachine training)..."); _log.Write(string.Empty); Console.ReadLine(); //Instantiation and training _log.Write("StateMachine training:"); _log.Write("----------------------"); _log.Write(string.Empty); //StateMachine instance StateMachine stateMachine = new StateMachine(stateMachineCfg); //StateMachine training TrainStateMachine(stateMachine, ".\\Data\\TTOO.csv", out double[] predictionInputVector); //Serialize StateMachine string serializationFileName = ".\\Examples\\TTOOForecastFromScratchSM.dat"; stateMachine.SaveToFile(serializationFileName); //Forecast ReadoutLayer.ReadoutData readoutData = stateMachine.ComputeReadoutData(predictionInputVector); _log.Write(" Forecast next High and Low (real values are High=6.58$ and Low=5.99$):", false); _log.Write(stateMachine.RL.GetForecastReport(readoutData.DataVector, 6)); _log.Write(string.Empty); //New StateMachine instance from the file StateMachine stateMachineNewInstance = StateMachine.LoadFromFile(serializationFileName); //New StateMachine instance forecast (exactly the same results as previous) readoutData = stateMachineNewInstance.ComputeReadoutData(predictionInputVector); _log.Write(" Forecast of the new StateMachine instance:", false); _log.Write(stateMachineNewInstance.RL.GetForecastReport(readoutData.DataVector, 6)); _log.Write(string.Empty); return; }
/// <summary> /// Runs the example code. /// </summary> public void Run() { //Create StateMachine configuration //Simplified input configuration InputEncoderSettings inputCfg = StateMachineDesigner.CreateInputCfg(new FeedingContinuousSettings(FeedingContinuousSettings.AutoBootCyclesNum), true, new ExternalFieldSettings("High", new RealFeatureFilterSettings()), new ExternalFieldSettings("Low", new RealFeatureFilterSettings()), new ExternalFieldSettings("Adj Close", new RealFeatureFilterSettings()) ); //Simplified readout layer configuration ReadoutLayerSettings readoutCfg = StateMachineDesigner.CreateForecastReadoutCfg(StateMachineDesigner.CreateSingleLayerRegrNet(new IdentitySettings(), 2, 1000), 0.1d, 1, "High", "Low" ); //Create designer instance StateMachineDesigner smd = new StateMachineDesigner(inputCfg, readoutCfg); //Create pure ESN fashioned StateMachine configuration StateMachineSettings stateMachineCfg = smd.CreatePureESNCfg(250, 1, 0, 0.2d, 0, 0.1d, 0.75d, null, PredictorsProvider.PredictorID.Activation, PredictorsProvider.PredictorID.ActivationSquare); //Display StateMachine xml configuration string xmlConfig = stateMachineCfg.GetXml(true).ToString(); _log.Write("StateMachine configuration xml:"); _log.Write("-------------------------------"); _log.Write(xmlConfig); _log.Write(string.Empty); _log.Write("Pres Enter to continue (StateMachine training)..."); _log.Write(string.Empty); Console.ReadLine(); //Instantiation and training _log.Write("StateMachine training:"); _log.Write("----------------------"); _log.Write(string.Empty); //StateMachine instance StateMachine stateMachine = new StateMachine(stateMachineCfg); //StateMachine training TrainStateMachine(stateMachine, ".\\Data\\TTOO.csv", out double[] predictionInputVector); //Forecast ReadoutLayer.ReadoutData readoutData = stateMachine.ComputeReadoutData(predictionInputVector); _log.Write(" Forecast next High and Low (real values are High=6.58$ and Low=5.99$):", false); _log.Write(stateMachine.RL.GetForecastReport(readoutData.DataVector, 6)); _log.Write(string.Empty); return; }
//Methods /// <summary> /// Updates the statistics. /// </summary> /// <param name="inputValues">The input values</param> /// <param name="readoutData">The computed readout data.</param> /// <param name="idealValues">The ideal values.</param> public void Update(double[] inputValues, ReadoutLayer.ReadoutData readoutData, double[] idealValues) { //Store input, computed and ideal values ComputationResultBundle.InputVectorCollection.Add(inputValues); ComputationResultBundle.ComputedVectorCollection.Add(readoutData.NatDataVector); ComputationResultBundle.IdealVectorCollection.Add(idealValues); //Update statistics foreach (ReadoutUnitErrorStat ruStat in ReadoutUnitStatCollection) { ruStat.Update(readoutData.NatDataVector, idealValues); } foreach (OneTakesAllGroupErrorStat grStat in OneTakesAllGroupStatCollection) { grStat.Update(readoutData, idealValues); } return; }
/// <summary> /// Preprocesses the data and computes the readout layer. /// </summary> /// <param name="inputVector">The input vector.</param> /// <param name="readoutData">The detailed data computed by the readout layer.</param> /// <returns>The computed output values in the natural form.</returns> public double[] Compute(double[] inputVector, out ReadoutLayer.ReadoutData readoutData) { if (!RL.Trained) { throw new InvalidOperationException($"Readout layer is not trained."); } if (NP == null) { //Neural preprocessor is bypassed return(RL.Compute(inputVector, out readoutData)); } else { //Compute and return output return(RL.Compute(NP.Preprocess(inputVector), out readoutData)); } }
/// <summary> /// Performs given data bundle and evaluates computed results against ideal results /// Raises VerificationProgressChanged event. /// </summary> /// <param name="vectorBundle">Data bundle containing input vectors and desired output vectors</param> /// <returns>Verification result</returns> public VerificationResults Verify(VectorBundle vectorBundle) { VerificationResults verificationResults = new VerificationResults(Config.ReadoutLayerCfg); for (int sampleIdx = 0; sampleIdx < vectorBundle.InputVectorCollection.Count; sampleIdx++) { double[] predictors; if (NP == null) { //Neural preprocessor is bypassed predictors = vectorBundle.InputVectorCollection[sampleIdx]; } else { //Neural preprocessing predictors = NP.Preprocess(vectorBundle.InputVectorCollection[sampleIdx]); } ReadoutLayer.ReadoutData readoutData = RL.ComputeReadoutData(predictors); verificationResults.Update(predictors, readoutData, vectorBundle.OutputVectorCollection[sampleIdx]); VerificationProgressChanged(vectorBundle.InputVectorCollection.Count, sampleIdx + 1); } return(verificationResults); }