// ------------------------------------------------------------------------------------
// Print Matrix Elements
// ------------------------------------------------------------------------------------
public static void PrintList(ManagedIntList input, bool vert = false)
{
for (int x = 0; x < input.x; x++)
{
if (!vert)
{
if (x > 0)
{
Console.Write(" ");
}
}
else
{
Console.Write("{0}: ", x.ToString("D", ci));
}
Console.Write("{0}", input[x].ToString("D", ci));
if (vert)
{
Console.WriteLine();
}
}
if (!vert)
{
Console.WriteLine();
}
}
public void Train(ManagedArray input, ManagedArray output, ConvolutionalNeuralNetworkOptions opts)
{
var temp_input = new ManagedArray(input.x, input.y, opts.BatchSize, false);
var temp_output = new ManagedArray(opts.BatchSize, output.y, false);
var index_list = new ManagedIntList(opts.Items);
for (var epoch = 0; epoch < opts.Epochs; epoch++)
{
var start = Profiler.now();
if (opts.Shuffle)
{
ManagedOps.Shuffle(index_list);
}
var rLVal = 0.0;
rL.Clear();
for (var i = 0; i < opts.Items; i += opts.BatchSize)
{
if (opts.Shuffle)
{
ManagedOps.Copy3D(temp_input, input, 0, 0, i, index_list);
ManagedOps.Copy2D(temp_output, output, i, 0, index_list);
}
else
{
ManagedOps.Copy3D(temp_input, input, 0, 0, i);
ManagedOps.Copy2D(temp_output, output, i, 0);
}
FeedForward(temp_input, opts.Pool);
BackPropagation(temp_output);
ApplyGradients(opts);
if (rL.Count == 0)
{
rL.Add(L);
}
rLVal = 0.99 * rL[rL.Count - 1] + 0.01 * L;
rL.Add(rLVal);
}
Console.WriteLine("epoch {0}/{1} elapsed time is {2} ms - Error: {3}", (epoch + 1).ToString("D", ManagedMatrix.ci), opts.Epochs.ToString("D", ManagedMatrix.ci), Profiler.Elapsed(start).ToString("D", ManagedMatrix.ci), rLVal.ToString("0.000000", ManagedMatrix.ci));
}
ManagedOps.Free(index_list);
ManagedOps.Free(temp_input, temp_output);
}
public ManagedIntList Classify(ManagedArray test, NeuralNetworkOptions opts, double threshold = 0.5)
{
Forward(test);
var classification = new ManagedIntList(test.y);
for (var y = 0; y < test.y; y++)
{
if (opts.Categories > 1)
{
var maxval = double.MinValue;
var maxind = 0;
for (var x = 0; x < opts.Categories; x++)
{
var val = Y[x, y];
if (val > maxval)
{
maxval = val;
maxind = x;
}
}
classification[y] = maxind + 1;
}
else
{
classification[y] = Y[y] > threshold ? 1 : 0;
}
}
// cleanup of arrays allocated in Forward propagation
ManagedOps.Free(Y);
for (var layer = 0; layer < Weights.GetLength(0); layer++)
{
ManagedOps.Free(X[layer], Z[layer]);
}
return(classification);
}
public ManagedIntList Classify(ManagedArray test, NeuralNetworkOptions opts, double threshold = 0.5)
{
Forward(test);
var classification = new ManagedIntList(test.y);
for (var y = 0; y < test.y; y++)
{
if (opts.Categories > 1)
{
var maxval = double.MinValue;
var maxind = 0;
for (var x = 0; x < opts.Categories; x++)
{
var val = Yk[x, y];
if (val > maxval)
{
maxval = val;
maxind = x;
}
}
classification[y] = maxind + 1;
}
else
{
classification[y] = Yk[y] > threshold ? 1 : 0;
}
}
// cleanup of arrays allocated in Forward
ManagedOps.Free(A2, Yk, Z2);
return(classification);
}
