/// <summary>
/// Train the network, using the specified training algorithm, and send the
/// output to the console.
/// </summary>
/// <param name="train">The training method to use.</param>
/// <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(ITrain train,
BasicNetwork network, INeuralDataSet trainingSet,
int minutes)
{
int epoch = 1;
long remaining;
Console.WriteLine("Beginning training...");
long start = Environment.TickCount;
do
{
train.Iteration();
long current = Environment.TickCount;
long elapsed = (current - start) / 1000;
remaining = minutes - elapsed / 60;
Console.WriteLine("Iteration #" + Format.FormatInteger(epoch)
+ " Error:" + Format.FormatPercent(train.Error)
+ " elapsed time = " + Format.FormatTimeSpan((int)elapsed)
+ " time left = "
+ Format.FormatTimeSpan((int)remaining * 60));
epoch++;
} while (remaining > 0 && !train.TrainingDone);
train.FinishTraining();
}
/// <summary>
/// Train to a specific error, using the specified training method, send the
/// output to the console.
/// </summary>
/// <param name="train">The training method.</param>
/// <param name="trainingSet">The training set to use.</param>
/// <param name="error">The desired error level.</param>
public static void TrainToError(ITrain train,
INeuralDataSet trainingSet,
double error)
{
int epoch = 1;
Console.WriteLine("Beginning training...");
do
{
train.Iteration();
Console.WriteLine("Iteration #" + Format.FormatInteger(epoch)
+ " Error:" + Format.FormatPercent(train.Error)
+ " Target Error: " + Format.FormatPercent(error));
epoch++;
} while (train.Error > error && !train.TrainingDone);
train.FinishTraining();
}
/// <inheritdoc/>
public void Run()
{
Stopwatch watch = new Stopwatch();
try
{
watch.Start();
OpenCLTrainingProfile profile = null;
#if !SILVERLIGHT
if (this is ConcurrentTrainingPerformerOpenCL)
{
EncogCLDevice device = ((ConcurrentTrainingPerformerOpenCL)this).Device;
profile = new OpenCLTrainingProfile(device,
this.currentJob.LocalRatio,
this.currentJob.GlobalRatio,
this.currentJob.SegmentationRatio);
}
#endif
this.currentJob.CreateTrainer(profile, Manager.SingleThreaded);
ITrain train = this.currentJob.Train;
int interation = 1;
while (this.currentJob.ShouldContinue())
{
train.Iteration(this.currentJob.IterationsPer);
interation++;
}
watch.Stop();
}
catch (Exception t)
{
this.currentJob.Error = t;
}
finally
{
lock (this)
{
this.ready = true;
}
this.Manager.JobDone(watch.ElapsedMilliseconds, this);
}
}
public static void Learn(INeuralDataSet learningSet, INeuralDataSet testingSet, int inputSize, InputClass inputData, int testingSize, int index)
{
string logDir = System.IO.Path.GetDirectoryName(Application.ExecutablePath);
int iteracje = inputData.iterations;
List <double> errors = new List <double>();
Console.WriteLine("Tworze siec...");
ITrain Network = NetworkHelper.CreateNeuronNetwork(learningSet, inputSize, inputData);
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
int iteracja = 0;
do
{
Network.Iteration();
errors.Add(Network.Error);
iteracja++;
} while ((iteracja < iteracje) && (Network.Error > 0.0001) && (Network.Error < 10000));
stopwatch.Stop();
String timeStamp = NetworkHelper.GetTimestamp(DateTime.Now);
/// TUTAJ SIEC SIE TEORETYCZNIE NAUCZYLA
/// TERAZ ZBIOR TESTOWY, WYNIKI
/// I WYKRES ERRORA
///
string errDir = logDir + "\\ERRORS\\err_" + timeStamp + "_" + ".r";
string log_name = timeStamp + "_" + index;
Logger(inputData.ToString(), logDir, log_name);
double[] neuralAnswer = new double[testingSize];
int i = 0;
foreach (INeuralDataPair pair in testingSet)
{
INeuralData output = Network.Network.Compute(pair.Input);
double small = 0.0;
for (int r = 0; r < 4; r++)
{
if ((double)(output[r]) >= small)
{
neuralAnswer[i] = (double)r;
small = (double)(output[r]);
}
}
i++;
}
int[] answers = NetworkHelper.DenormaliseAnswers(neuralAnswer);
Logger("Neural Network Learning Result" + Environment.NewLine, logDir, log_name);
Logger(errors[errors.Count - 1] + " %" + Environment.NewLine, logDir, log_name);
Logger("Neural Network Testing Result" + Environment.NewLine, logDir, log_name);
double calculateError = NetworkHelper.CalculateFinalError(answers, testingSet);
Logger("Error: " + calculateError + " %" + Environment.NewLine, logDir, log_name);
Logger(String.Format("Time elapsed: {0:hh\\:mm\\:ss}", stopwatch.Elapsed) + Environment.NewLine, logDir, log_name);
Console.WriteLine("FINISH");
NetworkHelper.CreateErrorFile(errors, errDir);
}
/// <summary>
/// Train to a specific error, using the specified training method, send the
/// output to the console.
/// </summary>
/// <param name="train">The training method.</param>
/// <param name="trainingSet">The training set to use.</param>
/// <param name="error">The desired error level.</param>
public static void TrainToError(ITrain train,
INeuralDataSet trainingSet,
double error)
{
int epoch = 1;
Console.WriteLine("Beginning training...");
do
{
train.Iteration();
Console.WriteLine("Iteration #" + Format.FormatInteger(epoch)
+ " Error:" + Format.FormatPercent(train.Error)
+ " Target Error: " + Format.FormatPercent(error));
epoch++;
} while (train.Error > error && !train.TrainingDone);
train.FinishTraining();
}
/// <summary>
/// Train the network, using the specified training algorithm, and send the
/// output to the console.
/// </summary>
/// <param name="train">The training method to use.</param>
/// <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(ITrain train,
BasicNetwork network, INeuralDataSet trainingSet,
int minutes)
{
int epoch = 1;
long remaining;
Console.WriteLine("Beginning training...");
long start = Environment.TickCount;
do
{
train.Iteration();
long current = Environment.TickCount;
long elapsed = (current - start) / 1000;
remaining = minutes - elapsed / 60;
Console.WriteLine("Iteration #" + Format.FormatInteger(epoch)
+ " Error:" + Format.FormatPercent(train.Error)
+ " elapsed time = " + Format.FormatTimeSpan((int)elapsed)
+ " time left = "
+ Format.FormatTimeSpan((int)remaining * 60));
epoch++;
} while (remaining > 0 && !train.TrainingDone);
train.FinishTraining();
}
public static ITrain LearnNetwork(INeuralDataSet learningSet, INeuralDataSet testingSet, int inputSize, InputClass inputData, int testingSize)
{
string logDir = System.IO.Path.GetDirectoryName(Application.ExecutablePath);
int iteracje = inputData.iterations;
List <double> errors = new List <double>();
Console.WriteLine("Tworze siec...");
ITrain Network = CreateNeuronNetwork(learningSet, inputSize, inputData);
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
int iteracja = 0;
do
{
Network.Iteration();
Console.WriteLine("Epoch #" + iteracja + " Error:" + Network.Error);
errors.Add(Network.Error);
iteracja++;
} while ((iteracja < iteracje) && (Network.Error > 0.0001) && (Network.Error < 10000));
stopwatch.Stop();
String timeStamp = GetTimestamp(DateTime.Now);
/// TUTAJ SIEC SIE TEORETYCZNIE NAUCZYLA
/// TERAZ ZBIOR TESTOWY, WYNIKI
/// I WYKRES ERRORA
///
string errDir = logDir + "ERRORS\\err_" + timeStamp + ".r";
Logger(inputData.ToString(), logDir, timeStamp);
double[] neuralAnswer = new double[testingSize];
int i = 0;
foreach (INeuralDataPair pair in testingSet)
{
INeuralData output = Network.Network.Compute(pair.Input);
double small = 0.0;
for (int r = 0; r < 4; r++)
{
if ((double)(output[r]) >= small)
{
neuralAnswer[i] = (double)r;
small = (double)(output[r]);
}
}
i++;
}
int[] answers = DenormaliseAnswers(neuralAnswer);
Logger("Neural Network Learning Result" + Environment.NewLine, logDir, timeStamp);
Logger(errors[errors.Count - 1] + " %" + Environment.NewLine, logDir, timeStamp);
Console.WriteLine("Neural Network Results");
Logger("Neural Network Testing Result" + Environment.NewLine, logDir, timeStamp);
double calculateError = CalculateFinalError(answers, testingSet);
Console.WriteLine("Error: " + calculateError + " %");
Logger("Error: " + calculateError + " %" + Environment.NewLine, logDir, timeStamp);
Console.WriteLine("Time elapsed: {0:hh\\:mm\\:ss}", stopwatch.Elapsed);
Logger(String.Format("Time elapsed: {0:hh\\:mm\\:ss}", stopwatch.Elapsed) + Environment.NewLine, logDir, timeStamp);
Console.WriteLine("FINISH");
if ((errors[errors.Count - 1] * 100).ToString().Length > 4)
{
inputData.learningError = (errors[errors.Count - 1] * 100).ToString().Substring(0, 4) + " %";
}
else
{
inputData.learningError = (errors[errors.Count - 1] * 100).ToString() + " %";
}
if (calculateError.ToString().Length > 4)
{
inputData.testingError = calculateError.ToString().Substring(0, 4) + " %";
}
else
{
inputData.testingError = calculateError.ToString() + " %";
}
inputData.timeElapsed = stopwatch.Elapsed.Hours + "h " + stopwatch.Elapsed.Minutes + "min " + stopwatch.Elapsed.Seconds + "sec";
CreateErrorFile(errors, errDir);
return(Network);
}
public static Tuple <double, ConfusionMatrix, double, double> LearnNetwork(INeuralDataSet learningSet, INeuralDataSet testingSet, int inputSize, InputClass inputData, int testingSize)
{
int iteracje = inputData.iterations;
List <double> errors = new List <double>();
Console.WriteLine("Tworze siec...");
ITrain Network = NetworkHelper.CreateNeuronNetwork(learningSet, inputSize, inputData);
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
int iteracja = 0;
do
{
Network.Iteration();
Console.WriteLine("Epoch #" + iteracja + " Error:" + Network.Error);
errors.Add(Network.Error);
iteracja++;
} while ((iteracja < iteracje) && (Network.Error > 0.0001) && (Network.Error < 10000));
stopwatch.Stop();
/// TUTAJ SIEC SIE TEORETYCZNIE NAUCZYLA
double[] neuralAnswer = new double[testingSize];
int i = 0;
foreach (INeuralDataPair pair in testingSet)
{
INeuralData output = Network.Network.Compute(pair.Input);
double small = 0.0;
for (int r = 0; r < 4; r++)
{
if ((double)(output[r]) >= small)
{
neuralAnswer[i] = (double)r;
small = (double)(output[r]);
}
}
i++;
}
int[] answers = NetworkHelper.DenormaliseAnswers(neuralAnswer);
double calculateError = NetworkHelper.CalculateFinalError(answers, testingSet);
if ((errors[errors.Count - 1] * 100).ToString().Length > 4)
{
inputData.learningError = (errors[errors.Count - 1] * 100).ToString().Substring(0, 4) + " %";
}
else
{
inputData.learningError = (errors[errors.Count - 1] * 100).ToString() + " %";
}
if (calculateError.ToString().Length > 4)
{
inputData.testingError = calculateError.ToString().Substring(0, 4) + " %";
}
else
{
inputData.testingError = calculateError.ToString() + " %";
}
inputData.timeElapsed = stopwatch.Elapsed.Hours + "h " + stopwatch.Elapsed.Minutes + "min " + stopwatch.Elapsed.Seconds + "sec";
ConfusionMatrix confusionMatrix = new ConfusionMatrix(4);
CalculateConfusionMatrix(confusionMatrix, answers, testingSet);
double precission = CalculatePrecission(confusionMatrix);
double recall = CalculateRecall(confusionMatrix);
return(new Tuple <double, ConfusionMatrix, double, double>(calculateError, confusionMatrix, precission, recall));
}
/*Zdazenie obslugujace klikniecie guzika Start. Funkcje sprawdza czy parametry sa poprawne. Jezeli tak
* to kontunuuje. Nastepnie przygotowuje zbiór traninowy
* Nastepnie tworzymy sieć. Na samym koncu uruchamiane sa obliczenia
*/
private void Start_Click(object sender, RoutedEventArgs e)
{
errors = new List <double>();
if (ValidateIntput() == false)
{
return;
}
INeuralDataSet learningSet, trainingSet;
learningSet = CombineTrainingSet(neuralInput, neuralIdeal);
trainingSet = CombineTrainingSet(neuralTestInput, neuralAnswers);
ITrain learning = CreateNeuronNetwork(learningSet);
int iteracja = 0;
INeuralData data = null;
INeuralDataPair dataPair = null;
foreach (INeuralDataPair pair in learningSet)
{
dataPair = pair;
data = pair.Input;
break;
}
INeuralData tmp = null;
do
{
learning.Iteration();
Console.WriteLine("OUTPUT IDEALNY: " + dataPair.Ideal);
tmp = learning.Network.Compute(data);
Console.WriteLine("WARTOŚĆ OFICJALNA:" + tmp.Data[0]);
Console.WriteLine("Epoch #" + iteracja + " Error:" + learning.Error);
errors.Add(learning.Error);
iteracja++;
} while ((iteracja < nHelp.liczbaIteracji) && (learning.Error > 0.0005));
// TUTAJ SKONCZYL SIE PROCES NAUKI
// POWINNISMY NA TA SIEC NALOZYC TERAZ ZBIOR TESTOWY
// ORAZ NARYSOWAC GRAFY
int i = 0;
Console.WriteLine("Neural Network Results:");
foreach (INeuralDataPair pair in trainingSet)
{
INeuralData output = learning.Network.Compute(pair.Input);
if (CBProblem.SelectedIndex == 0)
{
if (sety == 4)
{
if ((double)(output[0]) >= 0.6)
{
neuralAnswer[i] = 1.0;
}
else if ((double)(output[1]) >= 0.6)
{
neuralAnswer[i] = 2.0;
}
else if ((double)(output[2]) >= 0.6)
{
neuralAnswer[i] = 3.0;
}
else
{
neuralAnswer[i] = 4.0;
}
}
else if (sety == 3)
{
if ((double)(output[0]) >= 0.6)
{
neuralAnswer[i] = 1.0;
}
else if ((double)(output[1]) >= 0.6)
{
neuralAnswer[i] = 2.0;
}
else
{
neuralAnswer[i] = 3.0;
}
}
}
else
{
neuralAnswer[i] = output[0];
}
i++;
}
Console.WriteLine("Calculated");
CreateErrorFile();
if (CBProblem.SelectedIndex == 0)
{
CreateClassificationFile();
}
else
{
CreateRegressionFile();
}
}
