protected void InitializeEnvironments(int width, int height)
{
this.width = width;
this.height = height;
env = new float[width, height];
nextEnv = new float[width, height];
ResetEnvironment();
TrainingBatch = new TrainingBatch(1500);
}
public void Step()
{
float[] sampleInputCache = new float[9];
// string tmp = "";
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
nextEnv[x, y] = NextState(x, y);
FillSampleInputArray(x, y, sampleInputCache);
TrainingBatch.RecordSample(sampleInputCache, nextEnv[x, y]);
// tmp += nextEnv[x, y].ToString("F2") + " ";
}
// tmp += "\n";
}
// Debug.Log(tmp);
float[,] tmpEnv = env;
env = nextEnv;
nextEnv = tmpEnv;
}
// ///////////
//
// Training
//
// ///////////
internal void TrainFrom(TrainingBatch trainingBatch, float learningRate)
{
if (trainingBatch.Empty)
{
return;
}
FileLogger.WriteLine("Batch size: " + trainingBatch.Size + "\n");
FileLogger.WriteLine("Input --> Known Output, Prediction, Cost\n");
for (int k = 0; k < HiddenDimIncludingBias; k++)
{
hiddenToOutputCorrections[k] = 0;
for (int i = 0; i < INPUT_DIM_INCLUDING_BIAS; i++)
{
inputToHiddenCorrections[k, i] = 0;
}
}
// This is stored here because after the batch is consumed, its size will be zero.
int trainingBatchSize = trainingBatch.Size;
trainingBatch.ConsumeBatch((inputSample, knownOutput, sampleNumber) =>
{
LogSample(inputSample, knownOutput);
SetInputTmp(inputSample);
float predictedOutput = ComputeOutputFromInputField();
float cost = (predictedOutput - knownOutput) * (predictedOutput - knownOutput);
PreviousMinBatchCost = Mathf.Min(PreviousMinBatchCost, cost);
PreviousMaxBatchCost = Mathf.Max(PreviousMaxBatchCost, cost);
PreviousAvgBatchCost += cost;
FileLogger.Write(predictedOutput.ToString("F1") + ", ");
FileLogger.Write(cost.ToString("F2"));
// BEGIN tHE DERIVATIVES. BYE READABILITY. 👋
float yp = predictedOutput;
float yt = knownOutput;
float di_yp = 2f * (yp - yt);
float di_zy = di_yp * yp * (1f - yp);
float[] di_wh = new float[HiddenDimIncludingBias];
float[] di_h = new float[HiddenDimIncludingBias];
float[] di_zh = new float[HiddenDimIncludingBias];
for (int k = 0; k < HiddenDimIncludingBias; k++)
{
float hk = previousForwardHiddenState[k];
float wk = hiddenToOutputWeights[k];
di_wh[k] = di_zy * hk;
di_h[k] = di_zy * wk;
di_zh[k] = di_h[k] * hk * (1f - hk);
// gradient descent on hidden layer weights
hiddenToOutputWeights[k] += -learningRate * di_wh[k];
// hiddenToOutputCorrections[k] += di_wh[k];
}
float[,] di_w = new float[HiddenDimIncludingBias, INPUT_DIM_INCLUDING_BIAS];
for (int k = 0; k < HiddenDimIncludingBias; k++)
{
for (int i = 0; i < INPUT_DIM_INCLUDING_BIAS; i++)
{
float xi = previousForwardInput[i];
di_w[k, i] = di_zh[k] * xi;
// gradient descent on input layer weights
inputToHiddenWeights[k, i] += -learningRate * di_w[k, i];
// inputToHiddenCorrections[k, i] += di_w[k, i];
}
}
FileLogger.Write("\n");
});
// for (int k = 0; k < HiddenDimIncludingBias; k++) {
// hiddenToOutputWeights[k] += -learningRate * hiddenToOutputCorrections[k] / trainingBatchSize;
// for (int i = 0; i < INPUT_DIM_INCLUDING_BIAS; i++) {
// inputToHiddenWeights[k, i] += -learningRate * inputToHiddenCorrections[k, i] / trainingBatchSize;
// }
// }
PreviousAvgBatchCost /= trainingBatchSize;
}
