public ManagedArray Predict(ManagedArray test, NeuralNetworkOptions opts)
{
Forward(test);
var prediction = new ManagedArray(test.y);
for (var y = 0; y < test.y; y++)
{
if (opts.Categories > 1)
{
double maxval = Double.MinValue;
for (var x = 0; x < opts.Categories; x++)
{
double val = Yk[x, y];
if (val > maxval)
{
maxval = val;
}
}
prediction[y] = maxval;
}
else
{
prediction[y] = Yk[y];
}
}
// cleanup of arrays allocated in Forward
ManagedOps.Free(A2, Yk, Z2);
return(prediction);
}
public void ApplyGradients(NeuralNetworkOptions opts)
{
for (var layer = 0; layer < Weights.GetLength(0); layer++)
{
ManagedMatrix.Add(Weights[layer], Deltas[layer], -opts.Alpha);
}
}
public void Optimize(ManagedArray input, ManagedArray output, NeuralNetworkOptions opts)
{
SetupOptimizer(input, output, opts);
while (!StepOptimizer(input, opts))
{
}
}
public void Train(ManagedArray input, ManagedArray output, NeuralNetworkOptions opts)
{
Setup(output, opts);
while (!Step(input, opts))
{
}
}
public void ApplyGradients(NeuralNetworkOptions opts)
{
// dWji = learning_rate * dWji
// dWkj = learning_rate * dWkj
// w_ji = w_ji - dWji
// w_kj = w_kj - dWkj
ManagedMatrix.Add(Wkj, DeltaWkj, -opts.Alpha);
ManagedMatrix.Add(Wji, DeltaWji, -opts.Alpha);
}
public bool Step(ManagedArray input, NeuralNetworkOptions opts)
{
Forward(input);
BackPropagation(input);
ApplyGradients(opts);
Iterations = Iterations + 1;
return(double.IsNaN(Cost) || Iterations >= opts.Epochs || Cost < opts.Tolerance);
}
public void SetupOptimizer(ManagedArray input, ManagedArray output, NeuralNetworkOptions opts, bool Reset = true)
{
Setup(output, opts, Reset);
Optimizer.MaxIterations = opts.Epochs;
var X = ReshapeWeights(Wji, Wkj);
OptimizerInput = input;
Optimizer.Setup(OptimizerCost, X);
}
public void ApplyGradients(NeuralNetworkOptions opts)
{
// dWji = learning_rate * dWji
// dWkj = learning_rate * dWkj
// w_ji = w_ji - dWji
// w_kj = w_kj - dWkj
ManagedMatrix.Add(Wkj, DeltaWkj, -opts.Alpha);
ManagedMatrix.Add(Wji, DeltaWji, -opts.Alpha);
// cleanup of arrays allocated in BackPropagation
ManagedOps.Free(DeltaWji, DeltaWkj);
}
public bool StepOptimizer(ManagedArray input, NeuralNetworkOptions opts)
{
OptimizerInput = input;
var X = ReshapeWeights(Wji, Wkj);
Optimizer.Step(OptimizerCost, X);
Iterations = Optimizer.Iterations;
Cost = Optimizer.f1;
OptimizerInput = null;
return(double.IsNaN(Cost) || Iterations >= opts.Epochs || Cost < opts.Tolerance);
}
public void Setup(ManagedArray output, NeuralNetworkOptions opts)
{
Wji = new ManagedArray(opts.Inputs + 1, opts.Nodes);
Wkj = new ManagedArray(opts.Nodes + 1, opts.Categories);
Y_output = Labels(output, opts);
var random = new Random(Guid.NewGuid().GetHashCode());
Rand(Wji, random);
Rand(Wkj, random);
Cost = 1.0;
L2 = 1.0;
Iterations = 0;
}
public bool Step(ManagedArray input, NeuralNetworkOptions opts)
{
Forward(input);
BackPropagation(input);
var optimized = (double.IsNaN(Cost) || Cost < opts.Tolerance);
if (!optimized)
{
ApplyGradients(opts);
}
ClearDeltas();
Iterations = Iterations + 1;
return(optimized || Iterations >= opts.Epochs);
}
public bool Step(ManagedArray input, NeuralNetworkOptions opts)
{
Forward(input);
BackPropagation(input);
var optimized = (double.IsNaN(opts.UseL2 ? L2 : Cost) || (opts.UseL2 ? L2 : Cost) < opts.Tolerance);
// Apply gradients only if the error is still high
if (!optimized)
{
ApplyGradients(opts);
}
ClearDeltas();
Iterations = Iterations + 1;
return(optimized || Iterations >= opts.Epochs);
}
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 ManagedArray Predict(ManagedArray test, NeuralNetworkOptions opts)
{
Forward(test);
var prediction = new ManagedArray(test.y);
for (var y = 0; y < test.y; y++)
{
if (opts.Categories > 1)
{
double maxval = Double.MinValue;
for (var x = 0; x < opts.Categories; x++)
{
double val = Y[x, y];
if (val > maxval)
{
maxval = val;
}
}
prediction[y] = maxval;
}
else
{
prediction[y] = Y[y];
}
}
// cleanup of arrays allocated in Forward propagation
ManagedOps.Free(Y);
// Cleanup
for (var layer = 0; layer < Weights.GetLength(0); layer++)
{
ManagedOps.Free(X[layer], Z[layer]);
}
return(prediction);
}
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);
}
ManagedArray Labels(ManagedArray output, NeuralNetworkOptions opts)
{
var result = new ManagedArray(opts.Categories, opts.Items);
var eye_matrix = ManagedMatrix.Diag(opts.Categories);
for (var y = 0; y < opts.Items; y++)
{
if (opts.Categories > 1)
{
for (var x = 0; x < opts.Categories; x++)
{
result[x, y] = eye_matrix[x, (int)output[y] - 1];
}
}
else
{
result[y] = output[y];
}
}
ManagedOps.Free(eye_matrix);
return(result);
}
public void SetupLabels(ManagedArray output, NeuralNetworkOptions opts)
{
Y_output = Labels(output, opts);
}
public void Setup(ManagedArray output, NeuralNetworkOptions opts, bool Reset = true)
{
if (Reset)
{
if (Activations != null && Activations.GetLength(0) > 0)
{
for (var layer = 0; layer < Activations.GetLength(0); layer++)
{
ManagedOps.Free(Activations[layer]);
}
}
if (D != null && D.GetLength(0) > 0)
{
for (var layer = 0; layer < D.GetLength(0); layer++)
{
ManagedOps.Free(D[layer]);
}
}
if (Deltas != null && Deltas.GetLength(0) > 0)
{
for (var layer = 0; layer < Deltas.GetLength(0); layer++)
{
ManagedOps.Free(Deltas[layer]);
}
}
if (X != null && X.GetLength(0) > 0)
{
for (var layer = 0; layer < X.GetLength(0); layer++)
{
ManagedOps.Free(X[layer]);
}
}
if (Z != null && Z.GetLength(0) > 0)
{
for (var layer = 0; layer < Z.GetLength(0); layer++)
{
ManagedOps.Free(Z[layer]);
}
}
if (Weights != null && Weights.GetLength(0) > 0)
{
for (var layer = 0; layer < Weights.GetLength(0); layer++)
{
ManagedOps.Free(Weights[layer]);
}
}
if (Layers.Count > 0)
{
Weights = new ManagedArray[Layers.Count];
for (var layer = 0; layer < Layers.Count; layer++)
{
Weights[layer] = new ManagedArray(Layers[layer].Inputs + 1, Layers[layer].Outputs);
}
}
else
{
Weights = new ManagedArray[opts.HiddenLayers + 1];
Weights[0] = new ManagedArray(opts.Inputs + 1, opts.Nodes);
Layers.Add(new HiddenLayer(opts.Inputs, opts.Nodes));
for (var layer = 1; layer < opts.HiddenLayers; layer++)
{
Weights[layer] = (new ManagedArray(opts.Nodes + 1, opts.Nodes));
Layers.Add(new HiddenLayer(opts.Nodes, opts.Nodes));
}
Weights[opts.HiddenLayers] = (new ManagedArray(opts.Nodes + 1, opts.Categories));
Layers.Add(new HiddenLayer(opts.Nodes, opts.Categories));
}
}
Activations = new ManagedArray[opts.HiddenLayers];
Deltas = new ManagedArray[opts.HiddenLayers + 1];
X = new ManagedArray[opts.HiddenLayers + 1];
D = new ManagedArray[opts.HiddenLayers + 1];
Z = new ManagedArray[opts.HiddenLayers + 1];
SetupLabels(output, opts);
var random = new Random(Guid.NewGuid().GetHashCode());
if (Reset && Weights != null)
{
for (var layer = 0; layer < opts.HiddenLayers + 1; layer++)
{
Rand(Weights[layer], random);
}
}
Cost = 1.0;
L2 = 1.0;
Iterations = 0;
}
