//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);
}
