/// <summary>
/// Construct a gradient worker.
/// </summary>
///
/// <param name="network">The network to train.</param>
/// <param name="owner">The owner that is doing the training.</param>
/// <param name="training">The training data.</param>
/// <param name="low">The low index to use in the training data.</param>
/// <param name="high">The high index to use in the training data.</param>
public GradientWorkerCPU(FlatNetwork network,
TrainFlatNetworkProp owner,
IEngineIndexableSet training, int low, int high)
{
this.errorCalculation = new ErrorCalculation();
this.network = network;
this.training = training;
this.low = low;
this.high = high;
this.owner = owner;
this.stopwatch = new Stopwatch();
this.layerDelta = new double[network.LayerOutput.Length];
this.gradients = new double[network.Weights.Length];
this.actual = new double[network.OutputCount];
this.weights = network.Weights;
this.layerIndex = network.LayerIndex;
this.layerCounts = network.LayerCounts;
this.weightIndex = network.WeightIndex;
this.layerOutput = network.LayerOutput;
this.layerFeedCounts = network.LayerFeedCounts;
this.pair = BasicEngineData.CreatePair(network.InputCount,
network.OutputCount);
}
/// <summary>
/// Calculate the error for this neural network. The error is calculated
/// using root-mean-square(RMS).
/// </summary>
///
/// <param name="data">The training set.</param>
/// <returns>The error percentage.</returns>
public double CalculateError(IEngineIndexableSet data)
{
ErrorCalculation errorCalculation = new ErrorCalculation();
double[] actual = new double[this.outputCount];
IEngineData pair = BasicEngineData.CreatePair(data.InputSize,
data.IdealSize);
for (int i = 0; i < data.Count; i++)
{
data.GetRecord(i, pair);
Compute(pair.InputArray, actual);
errorCalculation.UpdateError(actual, pair.IdealArray);
}
return(errorCalculation.Calculate());
}
/// <summary>
/// Construct a kernel to train the network.
/// </summary>
///
/// <param name="device">The OpenCL device to use.</param>
/// <param name="flat">The network to train.</param>
/// <param name="training">The training data.</param>
/// <param name="tempDataSize">How much temp data.</param>
public KernelNetworkTrain(EncogCLDevice device,
FlatNetwork flat, IEngineIndexableSet training,
int tempDataSize)
: base(device, "Encog.Engine.Resources.KernelNetTrain.txt", "NetworkTrain")
{
this.training = training;
this.trainingLength = (int)this.training.Count;
this.device = device;
this.flat = flat;
this.weightInArray = new float[flat.Weights.Length];
this.weightOutArray = new float[flat.Weights.Length];
this.tempDataArray = new float[tempDataSize];
this.gradients = new float[flat.Weights.Length];
this.layerDeltaSize = 0;
for (int i = 0; i < flat.LayerCounts.Length; i++)
{
this.layerDeltaSize += flat.LayerCounts[i];
}
int inputSize = flat.InputCount;
int idealSize = flat.OutputCount;
this.inputArray = new float[inputSize * this.trainingLength];
this.idealArray = new float[idealSize * this.trainingLength];
this.paramArray = new int[10];
IEngineData pair = BasicEngineData.CreatePair(
flat.InputCount, flat.OutputCount);
int inputIndex = 0;
int idealIndex = 0;
for (int i = 0; i < this.trainingLength; i++)
{
training.GetRecord(i, pair);
for (int col = 0; col < flat.InputCount; col++)
{
this.inputArray[inputIndex++] = (float)pair.InputArray[col];
}
for (int col = 0; col < flat.OutputCount; col++)
{
this.idealArray[idealIndex++] = (float)pair.IdealArray[col];
}
}
}
