static void Main(string[] args)
{
//create a neural network withtout using a factory
var network = new BasicNetwork();
network.AddLayer(new BasicLayer(null, true, 2));
network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 2));
network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1));
network.Structure.FinalizeStructure();
network.Reset();
IMLDataSet trainingSet = new BasicMLDataSet(XORInput, XORIdeal);
IMLTrain train = new ResilientPropagation(network, trainingSet);
int epoch = 1;
do
{
train.Iteration();
Console.WriteLine($"Epoch #{epoch} Error: {train.Error}");
epoch++;
} while (train.Error > 0.01);
train.FinishTraining();
Console.WriteLine("Neural Network Results:");
foreach (IMLDataPair iPair in trainingSet)
{
IMLData output = network.Compute(iPair.Input);
Console.WriteLine($"{iPair.Input[0]}, {iPair.Input[0]}, actual={output[0]}, ideal={iPair.Ideal[0]}");
}
EncogFramework.Instance.Shutdown();
Console.ReadKey();
}
static void Main(string[] args)
{
var network = new BasicNetwork();
network.AddLayer(new BasicLayer(null, true, 2));
network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 3));
network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1));
network.Structure.FinalizeStructure();
network.Reset();
var trainingSet = new BasicMLDataSet(XORInput, XORIdeal);
var train = new ResilientPropagation(network, trainingSet);
var epoch = 1;
do
{
train.Iteration();
} while (train.Error > 0.01);
train.FinishTraining();
foreach (var pair in trainingSet)
{
var output = network.Compute(pair.Input);
Console.WriteLine(pair.Input[0] + @", " + pair.Input[1] + @" , actual=" + output[0] + @", ideal=" + pair.Ideal[0]);
}
EncogFramework.Instance.Shutdown();
Console.ReadLine();
}
private void Preprocessing_Completed(object sender, RunWorkerCompletedEventArgs e)
{
worker.ReportProgress(0, "Creating Network...");
BasicNetwork Network = new BasicNetwork();
Network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, DataContainer.NeuralNetwork.Data.InputSize));
Network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 50));
Network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, DataContainer.NeuralNetwork.Data.IdealSize));
Network.Structure.FinalizeStructure();
Network.Reset();
DataContainer.NeuralNetwork.Network = Network;
ResilientPropagation training = new ResilientPropagation(DataContainer.NeuralNetwork.Network, DataContainer.NeuralNetwork.Data);
worker.ReportProgress(0, "Running Training: Epoch 0");
for(int i = 0; i < 200; i++)
{
training.Iteration();
worker.ReportProgress(0, "Running Training: Epoch " + (i+1).ToString() + " Current Training Error : " + training.Error.ToString());
if(worker.CancellationPending == true)
{
completed = true;
return;
}
}
completed = true;
}
public void TestRPROPContPersistEG()
{
IMLDataSet trainingSet = XOR.CreateXORDataSet();
BasicNetwork net1 = XOR.CreateUnTrainedXOR();
BasicNetwork net2 = XOR.CreateUnTrainedXOR();
ResilientPropagation rprop1 = new ResilientPropagation(net1, trainingSet);
ResilientPropagation rprop2 = new ResilientPropagation(net2, trainingSet);
rprop1.Iteration();
rprop1.Iteration();
rprop2.Iteration();
rprop2.Iteration();
TrainingContinuation cont = rprop2.Pause();
EncogDirectoryPersistence.SaveObject(EG_FILENAME, cont);
TrainingContinuation cont2 = (TrainingContinuation)EncogDirectoryPersistence.LoadObject(EG_FILENAME);
ResilientPropagation rprop3 = new ResilientPropagation(net2, trainingSet);
rprop3.Resume(cont2);
rprop1.Iteration();
rprop3.Iteration();
for (int i = 0; i < net1.Flat.Weights.Length; i++)
{
Assert.AreEqual(net1.Flat.Weights[i], net2.Flat.Weights[i], 0.0001);
}
}
public void TestRPROPCont()
{
IMLDataSet trainingSet = XOR.CreateXORDataSet();
BasicNetwork net1 = XOR.CreateUnTrainedXOR();
BasicNetwork net2 = XOR.CreateUnTrainedXOR();
ResilientPropagation rprop1 = new ResilientPropagation(net1, trainingSet);
ResilientPropagation rprop2 = new ResilientPropagation(net2, trainingSet);
rprop1.Iteration();
rprop1.Iteration();
rprop2.Iteration();
rprop2.Iteration();
TrainingContinuation cont = rprop2.Pause();
ResilientPropagation rprop3 = new ResilientPropagation(net2, trainingSet);
rprop3.Resume(cont);
rprop1.Iteration();
rprop3.Iteration();
for (int i = 0; i < net1.Flat.Weights.Length; i++)
{
Assert.AreEqual(net1.Flat.Weights[i], net2.Flat.Weights[i], 0.0001);
}
}
public void TestRPROP()
{
IMLDataSet trainingData = new BasicMLDataSet(XOR.XORInput, XOR.XORIdeal);
BasicNetwork network = NetworkUtil.CreateXORNetworkUntrained();
IMLTrain rprop = new ResilientPropagation(network, trainingData);
NetworkUtil.TestTraining(rprop, 0.03);
}
public ResilientPropagation TrainNetwork(BasicNetwork network, BasicMLDataSet trainingData)
{
var trainedNetwork = new ResilientPropagation(network, trainingData);
var epoch = 0;
do
{
trainedNetwork.Iteration();
epoch++;
Console.WriteLine("Epoch:{0}, Error{1}", epoch, trainedNetwork.Error);
} while (trainedNetwork.Error > 0.01);
return trainedNetwork;
}
public void TestRPROPFolded()
{
IMLDataSet trainingData = XOR.CreateNoisyXORDataSet(10);
BasicNetwork network = NetworkUtil.CreateXORNetworkUntrained();
var folded = new FoldedDataSet(trainingData);
IMLTrain train = new ResilientPropagation(network, folded);
var trainFolded = new CrossValidationKFold(train, 4);
EncogUtility.TrainToError(trainFolded, 0.2);
XOR.VerifyXOR((IMLRegression) trainFolded.Method, 0.2);
}
/// <summary>
/// Evaluate how long it takes to calculate the error for the network. This
/// causes each of the training pairs to be run through the network. The
/// network is evaluated 10 times and the lowest time is reported.
/// </summary>
/// <param name="network">The training data to use.</param>
/// <param name="training">The number of seconds that it took.</param>
/// <returns></returns>
public static int EvaluateTrain(BasicNetwork network, IMLDataSet training)
{
// train the neural network
IMLTrain train = new ResilientPropagation(network, training);
int iterations = 0;
var watch = new Stopwatch();
watch.Start();
while (watch.ElapsedMilliseconds < (10*Milis))
{
iterations++;
train.Iteration();
}
return iterations;
}
public static int EvaluateTrain(BasicNetwork network, IMLDataSet training)
{
int num;
IMLTrain train = new ResilientPropagation(network, training);
if (0 == 0)
{
num = 0;
}
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
while (stopwatch.ElapsedMilliseconds < 0x2710L)
{
num++;
train.Iteration();
}
return num;
}
public double EvaluateMPROP(BasicNetwork network, IMLDataSet data)
{
var train = new ResilientPropagation(network, data);
long start = DateTime.Now.Ticks;
Console.WriteLine(@"Training 20 Iterations with MPROP");
for (int i = 1; i <= 20; i++)
{
train.Iteration();
Console.WriteLine("Iteration #" + i + " Error:" + train.Error);
}
//train.finishTraining();
long stop = DateTime.Now.Ticks;
double diff = new TimeSpan(stop - start).Seconds;
Console.WriteLine("MPROP Result:" + diff + " seconds.");
Console.WriteLine("Final MPROP error: " + network.CalculateError(data));
return diff;
}
public int Train(DataSet dataSet)
{
Network = new BasicNetwork();
Network.AddLayer(new BasicLayer(null, true, 8 * 21));
var first = ((8 * 21 + 4) * FirstLayerParameter);
Network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, (int)first));
var second = ((8 * 21 + 4) * SecondLayerParameter);
Network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, (int)second));
Network.AddLayer(new BasicLayer(null, false, 1));
// Network.AddLayer(new );
Network.Structure.FinalizeStructure();
Network.Reset();
//IMLData x = new BasicNeuralData();
var set = new double[dataSet.Signatures.Count + dataSet.Forgeries.Count][];
var ideal = new double[dataSet.Signatures.Count + dataSet.Forgeries.Count][];
for (int i = 0; i < dataSet.Signatures.Count; i++)
{
set[i] = dataSet.Signatures[i].Data.Cast<double>().ToArray();
ideal[i] = new double[] {1};
}
for (int i = dataSet.Signatures.Count; i < dataSet.Signatures.Count + dataSet.Forgeries.Count; i++)
{
set[i] = dataSet.Forgeries[i- dataSet.Signatures.Count].Data.Cast<double>().ToArray();
ideal[i] = new double[] { 0 };
}
IMLDataSet trainingSet = new BasicMLDataSet(set, ideal);
IMLTrain train = new ResilientPropagation(Network, trainingSet);
int epoch = 1;
var errors = new List<double>();
do
{
train.Iteration();
// Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error);
epoch++;
errors.Add(train.Error);
} while ( epoch < 10000);
train.FinishTraining();
return 1;
}
static void Main(string[] args)
{
double[][] XOR_Input =
{
new[] {0.0,0.0},
new[] {1.0,0.0},
new[] {0.0,1.0},
new[] {1.0,1.0}
};
double[][] XOR_Ideal =
{
new[] {0.0},
new[] {1.0},
new[] {1.0},
new[] {0.0}
};
var trainingSet = new BasicMLDataSet(XOR_Input, XOR_Ideal);
BasicNetwork network = CreateNetwork();
var train = new ResilientPropagation(network, trainingSet);
int epoch = 1;
do
{
train.Iteration();
epoch++;
Console.WriteLine("Iteration No :{0}, Error: {1}", epoch, train.Error);
} while (train.Error > 0.001);
foreach (var item in trainingSet)
{
var output = network.Compute(item.Input);
Console.WriteLine("Input : {0}, {1} Ideal : {2} Actual : {3}", item.Input[0], item.Input[1], item.Ideal[0], output[0]);
}
Console.WriteLine("press any key to exit...");
Console.ReadLine();
}
/// <summary>
/// Evaluate how long it takes to calculate the error for the network. This
/// causes each of the training pairs to be run through the network. The
/// network is evaluated 10 times and the lowest time is reported.
/// </summary>
/// <param name="network">The training data to use.</param>
/// <param name="training">The number of seconds that it took.</param>
/// <returns></returns>
public static int EvaluateTrain(BasicNetwork network, IMLDataSet training)
{
// train the neural network
IMLTrain train = new ResilientPropagation(network, training);
int iterations = 0;
const int milis10 = Milis * 10;
var watch = new Stopwatch();
watch.Start();
while (true)
{
iterations++;
train.Iteration();
if((iterations & 0xff) == 0 && watch.ElapsedMilliseconds < milis10) break;
}
return iterations;
}
public static int Evaluate(BasicNetwork network, IMLDataSet training)
{
ResilientPropagation rprop = new ResilientPropagation(network, training);
int iterations = 0;
for (; ; )
{
rprop.Iteration();
iterations++;
if (rprop.Error < TARGET_ERROR)
{
return iterations;
}
if (iterations > 1000)
{
iterations = 0;
return -1;
}
}
}
public void TestRPROPConsistency()
{
IMLDataSet training = EncoderTrainingFactory.generateTraining(4, false);
var network = EncogUtility.SimpleFeedForward(4, 2, 0, 4, true);
(new ConsistentRandomizer(-1, 1, 50)).Randomize(network);
var rprop = new ResilientPropagation(network, training);
for (var i = 0; i < 5; i++)
{
rprop.Iteration();
}
Assert.IsTrue(CompareArray.Compare(ExpectedWeights1, network.Flat.Weights,0.00001));
for (var i = 0; i < 5; i++)
{
rprop.Iteration();
}
Assert.IsTrue(CompareArray.Compare(ExpectedWeights2, network.Flat.Weights, 0.00001));
var e = network.CalculateError(training);
Assert.AreEqual(0.0767386807494191, e, 0.00001);
}
public double Run(List<int> topoplogy, int iterations)
{
_Network = new BasicNetwork();
_Network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, _Features));
foreach (int layer in topoplogy)
{
_Network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, layer));
}
_Network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 1));
_Network.Structure.FinalizeStructure();
_Network.Reset();
//Encog.Neural.Networks.Training.Propagation.Gradient.
ITrain train = new ResilientPropagation(_Network, _TrainingSet);
for (int i = 0; i < iterations; i++)
{
train.Iteration();
}
return train.Error;
}
private static void Main(string[] args)
{
// create a neural network, without using a factory
var network = new BasicNetwork();
network.AddLayer(new BasicLayer(null, true, 2));
network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 3));
network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 1));
network.Structure.FinalizeStructure();
network.Reset();
// create training data
IMLDataSet trainingSet = new BasicMLDataSet(XORInput, XORIdeal);
// train the neural network
IMLTrain train = new ResilientPropagation(network, trainingSet);
int epoch = 1;
do
{
train.Iteration();
Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error);
epoch++;
} while (train.Error > 0.01);
train.FinishTraining();
// test the neural network
Console.WriteLine(@"Neural Network Results:");
foreach (IMLDataPair pair in trainingSet)
{
IMLData output = network.Compute(pair.Input);
Console.WriteLine(pair.Input[0] + @"," + pair.Input[1]
+ @", actual=" + output[0] + @",ideal=" + pair.Ideal[0]);
}
EncogFramework.Instance.Shutdown();
}
private static void XORTest()
{
double[][] XOR_Input =
{
new[] {0.0, 0.0},
new[] {1.0, 0.0},
new[] {0.0, 1.0},
new[] {1.0, 1.0}
};
double[][] XOR_Ideal =
{
new[] {0.0},
new[] {1.0},
new[] {1.0},
new[] {0.0}
};
var trainingSet = new BasicMLDataSet(XOR_Input, XOR_Ideal);
var network = CreateNetwork();
var train = new ResilientPropagation(network, trainingSet);
int epoch = 1;
do
{
train.Iteration();
epoch++;
Console.WriteLine($"Iteration No: {epoch}, Error: {train.Error}");
} while (train.Error > 0.001);
foreach (var item in trainingSet)
{
var output = network.Compute(item.Input);
Console.WriteLine($"Input : {item.Input[0]}, {item.Input[1]}, Ideal: {item.Ideal[0]}, Actual : {output[0]}");
}
}
public void Perform(int thread)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var network = new BasicNetwork();
network.AddLayer(new BasicLayer(INPUT_COUNT));
network.AddLayer(new BasicLayer(HIDDEN_COUNT));
network.AddLayer(new BasicLayer(OUTPUT_COUNT));
network.Structure.FinalizeStructure();
network.Reset();
IMLDataSet training = RandomTrainingFactory.Generate(1000, 50000,
INPUT_COUNT, OUTPUT_COUNT, -1, 1);
var rprop = new ResilientPropagation(network, training);
rprop.ThreadCount = thread;
for (int i = 0; i < 5; i++)
{
rprop.Iteration();
}
stopwatch.Stop();
Console.WriteLine("Result with " + thread + " was " + stopwatch.ElapsedMilliseconds + "ms");
}
void Train()
{
if (Memory.Count>0)
{
network.Reset();
double[][] InputData = new double[Memory.Count][]; //подготовка данных для обучения сети
double[][] SenseData = new double[Memory.Count][];
for (int i = 0; i < Memory.Count; i++)
{
InputData[i] = Memory[i];
SenseData[i] = MemorySense[i];
}
IMLDataSet trainingSet = new BasicMLDataSet(InputData, SenseData);
IMLTrain train = new ResilientPropagation(network, trainingSet);
int epoch = 1;
double old = 9999;
double d = 999;
do
{
train.Iteration();
//Console.SetCursorPosition(0, 0); //вывод информации о текущем состоянии обучения
//Console.Write(@"Epoch #" + epoch + @" Error:" + train.Error);
epoch++;
d = Math.Abs(old - train.Error);
old = train.Error;
} while (train.Error > 0.0001 && epoch < 3000 && d > 0.00001);
train.FinishTraining();
//double sumd=0.0; //подсчет суммарной ошибки после обучения
//foreach (IMLDataPair pair in trainingSet)
//{
// IMLData output = network.Compute(pair.Input);
// sumd = sumd + Math.Abs(pair.Ideal[0] - output[0]);
// sumd = sumd / trainingSet.InputSize;
//}
}
}
/// <summary>
/// This is based off of this article:
/// http://www.codeproject.com/Articles/54575/An-Introduction-to-Encog-Neural-Networks-for-C
/// </summary>
/// <remarks>
/// Go here for documentation of encog:
/// http://www.heatonresearch.com/wiki
///
/// Download link:
/// https://github.com/encog/encog-dotnet-core/releases
/// </remarks>
private void btnXOR_Click(object sender, RoutedEventArgs e)
{
try
{
_trainingData = null;
_results = null;
BasicNetwork network = new BasicNetwork();
#region Create nodes
// Create the network's nodes
//NOTE: Using ActivationSigmoid, because there are no negative values. If there were negative, use ActivationTANH
//http://www.heatonresearch.com/wiki/Activation_Function
//NOTE: ActivationSigmoid (0 to 1) and ActivationTANH (-1 to 1) are pure but slower. A cruder but faster function is ActivationElliott (0 to 1) and ActivationElliottSymmetric (-1 to 1)
//http://www.heatonresearch.com/wiki/Elliott_Activation_Function
network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 2)); // input layer
network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 6)); // hidden layer
network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 1)); // output layer
network.Structure.FinalizeStructure();
// Randomize the links
network.Reset();
#endregion
#region Training data
// Neural networks must be trained before they are of any use. To train this neural network, we must provide training
// data. The training data is the truth table for the XOR operator. The XOR has the following inputs:
double[][] xor_input = new[]
{
new[] { 0d, 0d },
new[] { 1d, 0d },
new[] { 0d, 1d },
new[] { 1d, 1d },
};
// And the expected outputs
double[][] xor_ideal_output = new[]
{
new[] { 0d },
new[] { 1d },
new[] { 1d },
new[] { 0d },
};
_trainingData = GetDrawDataFromTrainingData(xor_input, xor_ideal_output);
#endregion
#region Train network
INeuralDataSet trainingSet = new BasicNeuralDataSet(xor_input, xor_ideal_output);
// This is a good general purpose training algorithm
//http://www.heatonresearch.com/wiki/Training
ITrain train = new ResilientPropagation(network, trainingSet);
List<double> log = new List<double>();
int trainingIteration = 1;
do
{
train.Iteration();
log.Add(train.Error);
trainingIteration++;
} while ((trainingIteration < 2000) && (train.Error > 0.001));
// Paste this into excel and chart it to see the error trend
string logExcel = string.Join("\r\n", log);
#endregion
#region Test
//NOTE: I initially ran a bunch of tests, but the network always returns exactly the same result when given the same inputs
//var test = Enumerable.Range(0, 1000).
// Select(o => new { In1 = _rand.Next(2), In2 = _rand.Next(2) }).
var test = xor_input.
Select(o => new { In1 = Convert.ToInt32(o[0]), In2 = Convert.ToInt32(o[1]) }).
Select(o => new
{
o.In1,
o.In2,
Expected = XOR(o.In1, o.In2),
NN = CallNN(network, o.In1, o.In2),
}).
Select(o => new { o.In1, o.In2, o.Expected, o.NN, Error = Math.Abs(o.Expected - o.NN) }).
OrderByDescending(o => o.Error).
ToArray();
#endregion
#region Test intermediate values
// It was only trained with inputs of 0 and 1. Let's see what it does with values in between
var intermediates = Enumerable.Range(0, 1000).
Select(o => new { In1 = _rand.NextDouble(), In2 = _rand.NextDouble() }).
Select(o => new
{
o.In1,
o.In2,
NN = CallNN(network, o.In1, o.In2),
}).
OrderBy(o => o.In1).
ThenBy(o => o.In2).
//OrderBy(o => o.NN).
ToArray();
#endregion
#region Serialize/Deserialize
// Serialize it
string weightDump = network.DumpWeights();
double[] dumpArray = weightDump.Split(',').
Select(o => double.Parse(o)).
ToArray();
//TODO: Shoot through the layers, and store in some custom structure that can be serialized, then walked through to rebuild on deserialize
//string[] layerDump = network.Structure.Layers.
// Select(o => o.ToString()).
// ToArray();
// Create a clone
BasicNetwork clone = new BasicNetwork();
clone.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 2));
clone.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 6));
clone.AddLayer(new BasicLayer(new ActivationSigmoid(), true, 1));
clone.Structure.FinalizeStructure();
clone.DecodeFromArray(dumpArray);
// Test the clone
string cloneDump = clone.DumpWeights();
bool isSame = weightDump == cloneDump;
var cloneTests = xor_input.
Select(o => new
{
Input = o,
NN = CallNN(clone, o[0], o[1]),
}).ToArray();
#endregion
#region Store results
double[] matchValues = new[] { 0d, 1d };
double matchRange = .03; //+- 5% of target value would be considered a match
_results = intermediates.
Select(o => Tuple.Create(new Point(o.In1, o.In2), o.NN, IsMatch(o.NN, matchValues, matchRange))).
ToArray();
#endregion
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), this.Title, MessageBoxButton.OK, MessageBoxImage.Error);
}
finally
{
RedrawResults();
}
}
/// <summary>
/// Train the network, to a specific error, send the output to the console.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="trainingSet">The training set to use.</param>
/// <param name="error">The error level to train to.</param>
public static void TrainToError(BasicNetwork network,
IMLDataSet trainingSet, double error)
{
Propagation train = new ResilientPropagation(network,
trainingSet) {ThreadCount = 0};
TrainToError(train, trainingSet, error);
}
/// <summary>
/// Train using RPROP and display progress to a dialog box.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="trainingSet">The training set to use.</param>
public static void TrainDialog(BasicNetwork network,
IMLDataSet trainingSet)
{
Propagation train = new ResilientPropagation(network,
trainingSet) {ThreadCount = 0};
TrainDialog(train, network, trainingSet);
}
/// <summary>
/// Train the neural network, using SCG training, and output status to the
/// console.
/// </summary>
/// <param name="network">The network to train.</param>
/// <param name="trainingSet">The training set.</param>
/// <param name="minutes">The number of minutes to train for.</param>
public static void TrainConsole(BasicNetwork network,
IMLDataSet trainingSet, int minutes)
{
Propagation train = new ResilientPropagation(network,
trainingSet) {ThreadCount = 0};
TrainConsole(train, network, trainingSet, minutes);
}
/// <summary>
/// Perform an individual job unit, which is a single network to train and
/// evaluate.
/// </summary>
///
/// <param name="context">Contains information about the job unit.</param>
public override sealed void PerformJobUnit(JobUnitContext context)
{
var network = (BasicNetwork) context.JobUnit;
BufferedMLDataSet buffer = null;
IMLDataSet useTraining = _training;
if (_training is BufferedMLDataSet)
{
buffer = (BufferedMLDataSet) _training;
useTraining = (buffer.OpenAdditional());
}
// train the neural network
double error = Double.PositiveInfinity;
for (int z = 0; z < _weightTries; z++)
{
network.Reset();
Propagation train = new ResilientPropagation(network,
useTraining);
var strat = new StopTrainingStrategy(0.001d,
5);
train.AddStrategy(strat);
train.ThreadCount = 1; // force single thread mode
for (int i = 0;
(i < _iterations) && !ShouldStop
&& !strat.ShouldStop();
i++)
{
train.Iteration();
}
error = Math.Min(error, train.Error);
}
if (buffer != null)
{
buffer.Close();
}
if (!ShouldStop)
{
// update min and max
_high = Math.Max(_high, error);
_low = Math.Min(_low, error);
if (_hidden1Size > 0)
{
int networkHidden1Count;
int networkHidden2Count;
if (network.LayerCount > 3)
{
networkHidden2Count = network.GetLayerNeuronCount(2);
networkHidden1Count = network.GetLayerNeuronCount(1);
}
else
{
networkHidden2Count = 0;
networkHidden1Count = network.GetLayerNeuronCount(1);
}
int row, col;
if (_hidden2Size == 0)
{
row = networkHidden1Count - _hidden[0].Min;
col = 0;
}
else
{
row = networkHidden1Count - _hidden[0].Min;
col = networkHidden2Count - _hidden[1].Min;
}
if ((row < 0) || (col < 0))
{
Console.Out.WriteLine("STOP");
}
_results[row][col] = error;
}
// report status
_currentTry++;
UpdateBest(network, error);
ReportStatus(
context,
"Current: "
+ NetworkToString(network)
+ "; Best: "
+ NetworkToString(_bestNetwork));
}
}
private void ProcessTrain()
{
if (network == null)
return;
String strMode = GetArg("mode");
String strMinutes = GetArg("minutes");
String strStrategyError = GetArg("strategyerror");
String strStrategyCycles = GetArg("strategycycles");
app.WriteLine("Training Beginning... Output patterns="
+ outputCount);
double strategyError = double.Parse(strStrategyError);
int strategyCycles = int.Parse(strStrategyCycles);
var train = new ResilientPropagation(network, training);
train.AddStrategy(new ResetStrategy(strategyError, strategyCycles));
if (String.Compare(strMode, "gui", true) == 0)
{
EncogUtility.TrainDialog(train, network, training);
}
else
{
int minutes = int.Parse(strMinutes);
EncogUtility.TrainConsole(train, network, training,
minutes);
}
app.WriteLine("Training Stopped...");
}
public void Train(BasicNetwork network, IMLDataSet training)
{
ITrain train = new ResilientPropagation(network, training);
int epoch = 1;
do
{
train.Iteration();
Console.WriteLine(@"Epoch #" + epoch + @" Error:" + train.Error);
epoch++;
} while (train.Error > MaxError);
}
/// <inheritdoc/>
public override void CreateTrainer(OpenCLTrainingProfile profile, bool singleThreaded)
{
Propagation.Propagation train = new ResilientPropagation(Network,
Training, profile, InitialUpdate, MaxStep);
if (singleThreaded)
train.NumThreads = 1;
else
train.NumThreads = 0;
foreach (IStrategy strategy in Strategies)
{
train.AddStrategy(strategy);
}
Train = train;
}
public void Train(Network network, TrainingCallback callback)
{
IActivationFunction activationFunctionInput = network.GetActivation(0);
int outputNeurons = network.GetLayerNeuronCount(network.LayerCount - 1);
double error = 0;
callback.Invoke(TrainingStatus.FillingStandardInputs, 0, 0, 0); /*First operation is filling standard input/outputs*/
Dictionary<int, List<BasicMLData>> trackIdFingerprints = GetNormalizedTrackFingerprints(activationFunctionInput, trainingSongSnippets, outputNeurons);
workingThread = Thread.CurrentThread;
IActivationFunction activationFunctionOutput = network.GetActivation(network.LayerCount - 1);
double[][] normalizedBinaryCodes = GetNormalizedBinaryCodes(activationFunctionOutput, outputNeurons);
Tuple<double[][], double[][]> tuple = FillStandardInputsOutputs(trackIdFingerprints, normalizedBinaryCodes); /*Fill standard input output*/
double[][] inputs = tuple.Item1;
double[][] outputs = tuple.Item2;
if (inputs == null || outputs == null)
{
callback.Invoke(TrainingStatus.Exception, 0, 0, 0);
return;
}
int currentIterration = 0;
double correctOutputs = 0.0;
BasicNeuralDataSet dataset = new BasicNeuralDataSet(inputs, outputs);
ITrain learner = new ResilientPropagation(network, dataset);
try
{
// Dynamic output reordering cycle
/*Idyn = 50*/
for (int i = 0; i < Idyn; i++)
{
if (paused)
{
pauseSem.WaitOne();
}
correctOutputs = NetworkPerformanceMeter.MeasurePerformance(network, dataset);
callback.Invoke(TrainingStatus.OutputReordering, correctOutputs, error, currentIterration);
ReorderOutput(network, dataset, trackIdFingerprints, normalizedBinaryCodes);
/*Edyn = 10*/
for (int j = 0; j < Edyn; j++)
{
if (paused)
{
pauseSem.WaitOne();
}
correctOutputs = NetworkPerformanceMeter.MeasurePerformance(network, dataset);
callback.Invoke(TrainingStatus.RunningDynamicEpoch, correctOutputs, error, currentIterration);
learner.Iteration();
error = learner.Error;
currentIterration++;
}
}
for (int i = 0; i < Efixed; i++)
{
if (paused)
{
pauseSem.WaitOne();
}
correctOutputs = NetworkPerformanceMeter.MeasurePerformance(network, dataset);
callback.Invoke(TrainingStatus.FixedTraining, correctOutputs, error, currentIterration);
learner.Iteration();
error = learner.Error;
currentIterration++;
}
network.ComputeMedianResponses(inputs, trainingSongSnippets);
callback.Invoke(TrainingStatus.Finished, correctOutputs, error, currentIterration);
}
catch (ThreadAbortException)
{
callback.Invoke(TrainingStatus.Aborted, correctOutputs, error, currentIterration);
paused = false;
}
}
