const uint iterations_between_reports = 1000; // nie potrzene
//static NeuralNetwork()
//{
// net = new NeuralNet(NetworkType.LAYER, num_layers, num_input, num_hidden, num_output);//typ warstwowa , ilosc warstw , wejscia, ukryta 1 (80) ,ukryta 2(60),wyjscia
//}
public void Train(string path)
{
//net = new NeuralNet(NetworkType.LAYER, num_layers, num_input, num_hidden, num_output);//typ warstwowa , ilosc warstw , wejscia, ukryta 1 (80) ,ukryta 2(60),wyjscia
if (path.Split('.').Last() == "net")
{
net = new NeuralNet(path);
}
else
{
net = new NeuralNet(NetworkType.LAYER, num_layers, num_input, num_hidden, num_output);
net.LearningRate = learning_rate;
net.ActivationSteepnessHidden = 0.8F;
net.ActivationSteepnessOutput = 1.0F;
net.ActivationFunctionHidden = ActivationFunction.SIGMOID_SYMMETRIC; //funkcja aktywacji sigmoidalna stepowa w wartwie ukrytej
net.ActivationFunctionOutput = ActivationFunction.SIGMOID; //funkcja aktywacji sigmoidalna w wartwie wyjsciowej
net.TrainingAlgorithm = TrainingAlgorithm.TRAIN_RPROP; //rodzaj nauki - propagacja wsteczna
using (TrainingData data = new TrainingData())
{
if (data.ReadTrainFromFile(path)) // czy plik istnieje jak tak to czyta
{
net.InitWeights(data); //inicjalizowanie wag wartośćiami losowymi
net.TrainOnData(data, max_iterations, iterations_between_reports, desired_error); //nauka sieci
}
}
}
}
static void Main(string[] argv)
{
const uint max_epochs = 1000;
uint num_threads = 1;
TrainingData data;
NeuralNet net;
long before;
float error;
if (argv.Length == 2)
num_threads = UInt32.Parse(argv[1]);
using (data = new TrainingData("..\\..\\..\\datasets\\mushroom.train"))
using (net = new NeuralNet(NetworkType.LAYER, 3, data.InputCount, 32, data.OutputCount))
{
net.ActivationFunctionHidden = ActivationFunction.SIGMOID_SYMMETRIC;
net.ActivationFunctionOutput = ActivationFunction.SIGMOID;
before = Environment.TickCount;
for (int i = 1; i <= max_epochs; i++)
{
error = num_threads > 1 ? net.TrainEpochIrpropmParallel(data, num_threads) : net.TrainEpoch(data);
Console.WriteLine("Epochs {0}. Current error: {1}", i.ToString("00000000"), error.ToString("0.0000000000"));
}
Console.WriteLine("ticks {0}", Environment.TickCount - before);
Console.ReadKey();
}
}
private void OpenFile(object sender, RoutedEventArgs e)
{
OpenFileDialog dlg = new OpenFileDialog();
dlg.DefaultExt = "*.pgm";
//dlg.Filter = "PGM Files (*.pgm)|*.pgm|JPEG Files (*.jpeg)|*.jpeg|PNG Files (*.png)|*.png|JPG Files (*.jpg)|*.jpg|GIF Files (*.gif)|*.gif";
dlg.Filter = "Image Files (*.pgm, *.jpeg, *.png, *.jpg, *.gif)|*.pgm; *.jpeg; *.png; *.jpg; *.gif";
dlg.Multiselect = true;
bool?result = dlg.ShowDialog();
if (result == true)
{
paths = new TrainingData[dlg.FileNames.Length];
for (int i = 0; i < paths.Length; i++)
{
paths[i] = new TrainingData {
filePath = dlg.FileNames[i], label = 0
};
}
pathIndex = 0;
LabelCurrent.Text = string.Format("{0}/{1}", pathIndex + 1, paths.Length);
SetPathToWindow(paths[pathIndex]);
isEditingXML = false;
BDelete.IsEnabled = false;
BUpdate.IsEnabled = false;
}
}
private double GradientB2(TrainingData sample, int index, double o, double[] w, double[] z)
{
var miB = SigmoidB(sample.Y, index);
var gradient = -1 * (sample.Y - A2[index]) * miB * (1 - miB) * SigmoidB(sample.Y, index);
return(GradientO(o, sample) * GradientW(index, w, z) * gradient);
}
private double GradientB1(TrainingData sample, int index, double o, double[] w, double[] z)
{
var miA = SigmoidA(sample.X, index);
var gradient = -1 * (sample.X - A1[index]) * miA * (1 - miA) * SigmoidB(sample.Y, index);
return(GradientO(o, sample) * GradientW(index, w, z) * gradient);
}
static void Main()
{
const uint num_input = 3;
const uint num_output = 1;
const uint num_layers = 4;
const uint num_neurons_hidden = 5;
const float desired_error = 0.0001F;
const uint max_epochs = 5000;
const uint epochs_between_reports = 1000;
using (NeuralNet net = new NeuralNet(NetworkType.LAYER, num_layers, num_input, num_neurons_hidden, num_neurons_hidden, num_output))
{
net.ActivationFunctionHidden = ActivationFunction.SIGMOID_SYMMETRIC;
net.ActivationFunctionOutput = ActivationFunction.LINEAR;
net.TrainingAlgorithm = TrainingAlgorithm.TRAIN_RPROP;
using (TrainingData data = new TrainingData("..\\..\\..\\datasets\\scaling.data"))
{
net.SetScalingParams(data, -1, 1, -1, 1);
net.ScaleTrain(data);
net.TrainOnData(data, max_epochs, epochs_between_reports, desired_error);
net.Save("..\\..\\..\\datasets\\scaling.net");
Console.ReadKey();
}
}
}
public OCRHandler(TrainingDataOptions openOptions)
{
TrainingData TDLibrary = new TrainingData(openOptions);
trainingLibrary = TDLibrary.trainingLibrary;
listOfIndicies = TDLibrary.listOfIndicies;
listOfIndexLabels = TDLibrary.listOfIndexLabels;
}
public async Task <IActionResult> Post([FromBody] TrainingData data)
{
var days = 0;
var result = string.Empty;
//Validate data.
result = data.ValidateDates(out days);
try
{
//If valid data then save.
if (days > 0)
{
var trainingDA = new TrainingDA();
var trainingData = new Training {
TrainingName = data.TrainingName, StartDate = data.StartDate, EndDate = data.EndDate
};
var saveFlag = await trainingDA.SaveTraining(trainingData);
result = Constants.ResponseMessages.Training_Save_Success;
return(Ok(new { result = result, days = days }));
}
return(BadRequest(new { error = result, days = days }));
}
catch (Exception ex)
{
//Need to log the error in logs like elastic search or log4net.
return(new StatusCodeResult(StatusCodes.Status500InternalServerError));
}
}
static void Main(string[] args)
{
var result = Parser.Default.ParseArguments <Options>(args);
var parsed = result as Parsed <Options>;
if (parsed != null)
{
SetupLogging();
var options = parsed.Value;
var logger = LogManager.GetLogger("Trainer");
logger.Info("Generating training data ...");
if (!options.SkipGeneration)
{
var data = new TrainingData();
data.Generate(options.TrainingSet);
data.Generate(options.TestSet);
}
var trainer = new NetworkTrainer();
trainer.Run(options.Model, options.TrainingSet, options.TestSet);
}
else
{
Console.WriteLine(HelpText.AutoBuild(result));
}
}
public ContextSensitiveSpellingCorrection(IPOSTagger posTagger, IEnumerable <string> corpora, IEnumerable <string[]> confusionSets, bool prune)
{
_posTagger = posTagger;
_contextFeaturesExtractor = new ContextFeaturesExtractor(k);
_collocationtFeaturesExtractor = new CollocationFeaturesExtractor(l);
_statsHelper = new StatsHelper();
_comparators = new List <Comparator>(confusionSets.Count());
Sentence[] sentences = PreProcessCorpora(corpora).ToArray();
/*processed corpus was serialized for faster results between trials*/
XmlSerializer x = new XmlSerializer(typeof(Sentence[]));
FileStream fs = new FileStream(@"Sentence.xml", FileMode.Open);
x.Serialize(fs, sentences);
fs.Close();
sentences = (Sentence[])x.Deserialize(new FileStream(@"Sentence.xml", FileMode.Open));
Console.WriteLine("Deserialize complete");
var featureFrequencies = new Dictionary <string, Dictionary <string, int> >(StringComparer.OrdinalIgnoreCase);
if (prune)
{
/* preprocess terms' frequencies */
featureFrequencies = _statsHelper.GetFrequencies(sentences);
}
Parallel.ForEach(confusionSets, confusionSet =>
{
TrainingData output = GenerateTrainingData(sentences, prune, featureFrequencies, confusionSet);
Train(confusionSet, output.Features.ToArray(), output.Samples);
});
}
public IHttpActionResult Post([FromBody] TrainingData training)
{
try
{
if (training == null)
{
return(BadRequest("Request had paramters"));
}
DateTime startDate = (DateTime)training.StartDate;
DateTime endDate = (DateTime)training.EndDate;
int days = (endDate - startDate).Days;
using (TrainingEntities entities = new TrainingEntities())
{
entities.TrainingDatas.Add(training);
entities.SaveChanges();
}
return(Ok(days));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
static void Main(string[] argv)
{
const uint max_epochs = 1000;
uint num_threads = 1;
TrainingData data;
NeuralNet net;
long before;
float error;
if (argv.Length == 2)
{
num_threads = UInt32.Parse(argv[1]);
}
using (data = new TrainingData("..\\..\\..\\datasets\\mushroom.train"))
using (net = new NeuralNet(NetworkType.LAYER, 3, data.InputCount, 32, data.OutputCount))
{
net.ActivationFunctionHidden = ActivationFunction.SIGMOID_SYMMETRIC;
net.ActivationFunctionOutput = ActivationFunction.SIGMOID;
before = Environment.TickCount;
for (int i = 1; i <= max_epochs; i++)
{
error = num_threads > 1 ? net.TrainEpochIrpropmParallel(data, num_threads) : net.TrainEpoch(data);
Console.WriteLine("Epochs {0}. Current error: {1}", i.ToString("00000000"), error.ToString("0.0000000000"));
}
Console.WriteLine("ticks {0}", Environment.TickCount - before);
Console.ReadKey();
}
}
public Data(byte[] data, byte label)
{
total = ConstantValues.TOTAL_IMAGES;
len = ConstantValues.TOTAL_PIXELS;
testing = new float[(int)Mathf.Floor(0.2f * total), len]; //4000 (images for testing)
training = new TrainingData(label); //4000 (images for testing)
for (int i = 0; i < total; i++)
{
int offset = i * len;
int threshold = (int)Mathf.Floor(0.8f * total); //16000 (images for training)
//Training
if (i < threshold)
{
for (int p = 0; p < len; ++p)
{
training.data[i, p] = data[offset + p] / 255.0f;
}
training.label = label;
training.data[i, ConstantValues.TOTAL_PIXELS] = label;
}
//Testing
else
{
for (int p = 0; p < len; ++p)
{
testing[i - threshold, p] = data[offset + p] / 255.0f;
}
}
}
}
public ActionResult LoadFromFile() //this is one time function, which we use for loading the data from external file
{
return(View()); //return because we loaded it once
if (!User.IsInRole("Admin")) //only admin can do this
{
return(new HttpUnauthorizedResult("Unauthorized"));
}
var fileContents = System.IO.File.ReadAllText(Server.MapPath("~/Content/load.csv"));
foreach (var line in fileContents.Split('\n'))
{
var arr = line.ToString().Split('~');
TrainingData tmp = new TrainingData(); //build new object of Training Data
if (arr.Length == 2)
{ //update it's data members from the file
tmp.title = arr[0];
tmp.word = arr[1];
db.TrainingDatas.Add(tmp); //add it to the Training Data table in the DB
}
}
db.SaveChanges();
return(Content(fileContents));
}
public void TrainXor()
{
NeuralNetworkBuilder builder = new NeuralNetworkBuilder();
NeuralNetwork network = builder.CreateNew()
.AddInputLayer(2, ActivationFunctions.Sigmoid, false)
.AddHiddenLayer(2, ActivationFunctions.Sigmoid, false)
.AddOutputLayer(1, ActivationFunctions.Sigmoid)
.GetNetwork();
BackPropagationTrainer trainer = new BackPropagationTrainer(network);
TrainingData[] data = new TrainingData[]
{
new TrainingData(new double[] { 1, 1 }, new double[] { 0 }),
new TrainingData(new double[] { 1, 0 }, new double[] { 1 }),
new TrainingData(new double[] { 0, 1 }, new double[] { 1 }),
new TrainingData(new double[] { 0, 0 }, new double[] { 0 }),
};
var result = trainer.Train(data, 100000, 0.7, 0.0, 0.005);
string csv = result.Errors.ToCsvString();
Assert.IsTrue(result.IsSuccessful, "could not traing against expected error");
double[] result1 = network.Run(new double[] { 1.0, 1.0 });
double[] result2 = network.Run(new double[] { 1.0, 0.0 });
double[] result3 = network.Run(new double[] { 0.0, 1.0 });
double[] result4 = network.Run(new double[] { 0.0, 0.0 });
Assert.IsTrue(result1[0].IsEqual(0, 0.0005));
Assert.IsTrue(result2[0].IsEqual(1, 0.0005));
Assert.IsTrue(result3[0].IsEqual(1, 0.0005));
Assert.IsTrue(result4[0].IsEqual(0, 0.0005));
}
private void CreateTrainAndTestData(double[][] inputSetsLocal, double[][] outputSetsLocal)
{
try
{
trainData = new TrainingData();
trainData.SetTrainData(inputSetsLocal, outputSetsLocal);
trainData.ScaleTrainData(-1.0, 1.0);
testData = new TrainingData(trainData);
testDataOffset = trainData.TrainDataLength / (uint)Configuration.TestDataAmountPerc;
testData.SubsetTrainData(0, testDataOffset);
testData.SaveTrain($@"{GetTempPath()}\testdata.dat");
testSetInput = testData.Input;
testSetOutput = testData.Output;
trainData.SubsetTrainData(testDataOffset, trainData.TrainDataLength - testDataOffset);
trainData.SaveTrain($@"{GetTempPath()}\traindata.dat");
trainSetInput = trainData.Input;
trainSetOutput = trainData.Output;
}
catch (Exception e)
{
debug($"Exception '{e.Message}' while working with train data");
Program.Form.SetStatus($"Exception '{e.Message}' while working with train data");
ClearAllParameters();
}
}
static void Main()
{
DataType[] calc_out;
Console.WriteLine("Creating network.");
using(NeuralNet net = new NeuralNet("..\\..\\..\\examples\\scaling.net"))
{
net.PrintConnections();
net.PrintParameters();
Console.WriteLine("Testing network.");
using (TrainingData data = new TrainingData("..\\..\\..\\datasets\\scaling.data"))
{
for (int i = 0; i < data.TrainDataLength; i++)
{
net.ResetMSE();
net.ScaleInput(data.GetTrainInput((uint)i));
calc_out = net.Run(data.GetTrainInput((uint)i));
net.DescaleOutput(calc_out);
Console.WriteLine("Result {0} original {1} error {2}", calc_out[0], data.OutputAccessor[i][0],
FannAbs(calc_out[0] - data.OutputAccessor[i][0]));
}
Console.ReadKey();
}
}
}
private static void BuildAddressList(string[] Raw)
{
foreach (string Address in Raw)
{
TrainingData Data = new TrainingData();
var Components = Address.Split(',');
Data.Street = Components[0];
var Coordinate = Components[1].Split(' ');
Data.Latitude = float.Parse(Coordinate[1]);
Data.Longitude = float.Parse(Coordinate[0]);
Int32 Id = 0;
float Rainfall = 0.0f;
Int32 Shortest = Int32.MaxValue;
foreach (var Gauge in Gauges)
{
var Temp = CalculateDistance(Data.Latitude, Data.Longitude, Gauge.Latitude, Gauge.Longitude);
if (Temp < Shortest && Gauge.MeterId != 2300)
{
Shortest = Temp;
Id = Gauge.MeterId;
Rainfall = Gauge.RainfallTotal;
}
}
Data.MeterId = Id;
Data.MeterDistance = Shortest;
Data.Rainfall = Rainfall;
Sources.Add(Data);
}
}
public void Setup(TrainingData trainData, TestData testData)
{
this.trainData = trainData;
this.testData = testData;
uod = DataFormatter.GetUserOrderRepositories(trainData);
}
public Form1()
{
trainingData = new TrainingData();
InitializeComponent();
initializeNeurons();
initNeuronsPrev();
}
static void Main()
{
const uint num_layers = 3;
const uint num_neurons_hidden = 96;
const float desired_error = 0.001F;
using (TrainingData trainData = new TrainingData("..\\..\\..\\datasets\\robot.train"))
using (TrainingData testData = new TrainingData("..\\..\\..\\datasets\\robot.test"))
{
for (float momentum = 0.0F; momentum < 0.7F; momentum += 0.1F)
{
Console.WriteLine("============= momentum = {0} =============\n", momentum);
using (NeuralNet net = new NeuralNet(NetworkType.LAYER, num_layers, trainData.InputCount, num_neurons_hidden, trainData.OutputCount))
{
net.TrainingAlgorithm = TrainingAlgorithm.TRAIN_INCREMENTAL;
net.LearningMomentum = momentum;
net.TrainOnData(trainData, 20000, 5000, desired_error);
Console.WriteLine("MSE error on train data: {0}", net.TestData(trainData));
Console.WriteLine("MSE error on test data: {0}", net.TestData(testData));
}
}
}
Console.ReadKey();
}
private static List <TrainingData <float[], float[]> > GetTrainingData(string imagesPath, string labelsPath)
{
var trainingData = new List <TrainingData <float[], float[]> >();
using (var labels = new BinaryReader(new FileStream(labelsPath, FileMode.Open)))
using (var images = new BinaryReader(new FileStream(imagesPath, FileMode.Open)))
{
//need to read some unnecessary values because of file format.
var magicNumber = ReadBigInt32(images);
var numberOfImages = ReadBigInt32(images);
var width = ReadBigInt32(images);
var height = ReadBigInt32(images);
var magicLabel = ReadBigInt32(labels);
var numberOfLabels = ReadBigInt32(labels);
for (var imageIndex = 0; imageIndex < numberOfImages; imageIndex++)
{
var bytes = images.ReadBytes(width * height);
var trainingDataItem = new TrainingData <float[], float[]>
{
//255 + 1 in order to make target no 1, but 0.9999.
Data = bytes.Select(b => (float)b / (255 + 1)).ToArray(),
Targets = ConvertNumberToTargetValues(labels.ReadByte())
};
trainingData.Add(trainingDataItem);
}
}
return(trainingData);
}
/*-------------------------
* Private Methods
* -------------------------*/
private void InverseResult(TrainingData data)
{
if (data.outData.left < 0.5f)
{
data.outData.left = 1.0f;
}
else
{
data.outData.left = 0.0f;
}
if (data.outData.right < 0.5f)
{
data.outData.right = 1.0f;
}
else
{
data.outData.right = 0.0f;
}
if (data.outData.forward < 0.5f)
{
data.outData.forward = 1.0f;
}
else
{
data.outData.forward = 0.0f;
}
}
public IHttpActionResult PutTrainingData(int id, TrainingData trainingData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != trainingData.ID)
{
return(BadRequest());
}
db.Entry(trainingData).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!TrainingDataExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void recorrerLectura(List<string> lectura, ref TrainingData td)
{
int i;
//Recorro cada linea del txt para ingresar los datos de entrenamiento
foreach (String linea in lectura)
{
for (i = 0; i <= 3; i++)
{
try
{ if(!linea.Split(';')[i].Equals("")){
cargarNumeroComoArrayInput(Convert.ToInt32(linea.Split(';')[i]), ref td);
}
}
catch (FormatException e)
{
Console.WriteLine("Input string is not a sequence of digits.");
}
catch (OverflowException e)
{
Console.WriteLine("The number cannot fit in an Int32.");
}
cargarNumeroComoArrayOutput(Convert.ToInt32(linea.Split(';')[4]), ref td);
}
}
}
public LotteryPredictionResult PredictionOneToFile(string webRootPath, string noSite, string noType, TrainingData data, string lotteryCode)
{
var pipeline = new LearningPipeline();
string dataPath = webRootPath + $"/TrainingGround/{noSite}{noType}.txt";
pipeline.Add(new TextLoader(dataPath).CreateFrom <TrainingData>(separator: ','));
pipeline.Add(new Dictionarizer("Label"));
pipeline.Add(new ColumnConcatenator("Features", TrainingData.GetColumns()));
pipeline.Add(new LogisticRegressionBinaryClassifier());
pipeline.Add(new PredictedLabelColumnOriginalValueConverter()
{
PredictedLabelColumn = "PredictedLabel"
});
_logger.LogInformation("Start PredictionOne :" + lotteryCode + "—" + noSite + noType);
var model = pipeline.Train <TrainingData, LotteryPrediction>();
var testData = new TextLoader(dataPath).CreateFrom <TrainingData>(separator: ',');
var evaluator = new BinaryClassificationEvaluator();
var metrics = evaluator.Evaluate(model, testData);
TrainingData newPoint = data;
LotteryPrediction prediction = model.Predict(newPoint);
string result = prediction.PredictedLabels;
_logger.LogInformation("End PredictionOne :" + lotteryCode + "—" + noSite + noType);
return(new LotteryPredictionResult()
{
PredictionType = noType,
PredictionSite = noSite,
PredictionResult = result,
LotteryCode = lotteryCode
});
}
static List <TrainingData <float[], float> > GetNandTrainingData()
{
var trainingDataFilePath = $"{Environment.CurrentDirectory}/Resources/NAND_training_data.txt";
var trainingDataSet = new List <TrainingData <float[], float> >();
var lines = File.ReadAllLines(trainingDataFilePath);
foreach (var line in lines)
{
var splitLine = line.Split(" ");
var firstInput = float.Parse(splitLine[0]);
var secondInput = float.Parse(splitLine[1]);
var target = float.Parse(splitLine[2]);
var trainingData = new TrainingData <float[], float>
{
Data = new[] { firstInput, secondInput },
Targets = target
};
trainingDataSet.Add(trainingData);
}
return(trainingDataSet);
}
static void Main()
{
DataType[] calc_out;
Console.WriteLine("Creating network.");
using (NeuralNet net = new NeuralNet("..\\..\\..\\examples\\scaling.net"))
{
net.PrintConnections();
net.PrintParameters();
Console.WriteLine("Testing network.");
using (TrainingData data = new TrainingData("..\\..\\..\\datasets\\scaling.data"))
{
for (int i = 0; i < data.TrainDataLength; i++)
{
net.ResetMSE();
net.ScaleInput(data.GetTrainInput((uint)i));
calc_out = net.Run(data.GetTrainInput((uint)i));
net.DescaleOutput(calc_out);
Console.WriteLine("Result {0} original {1} error {2}", calc_out[0], data.OutputAccessor[i][0],
FannAbs(calc_out[0] - data.OutputAccessor[i][0]));
}
Console.ReadKey();
}
}
}
///<summary>
///Only for classification, called by Function "CorrectClassified"
///</summary>
public bool evaluateTrainingSet(TrainingData d)
{
this.SetInputVector(d.input);
this.Invalidate();
List <double> o;
o = this.GetOutputVector();
int index = 0;
int i = 0;
//searching for the index of the highest value in outputvector
foreach (double v in o)
{
if (o.ElementAt(index) < v)
{
index = i;
}
++i;
}
//compare the index to the output vector of the trainings set
//if the value at this index is 1 the classification was correct
if (d.output.ElementAt(index) == 1.0)
{
return(true);
}
else
{
return(false);
}
}
public override void TestInitialize()
{
base.TestInitialize();
coaches = new TestRepository();
entries = new TestTimetableEntriesRepository();
trainings = new TestTrainingsRepository();
locations = new TestLocationsRepository();
types = new TestTrainingTypesRepository();
data = GetRandom.Object <CoachData>();
var c = new Coach(data);
coaches.Add(c).GetAwaiter();
trainingData = GetRandom.Object <TrainingData>();
var t = new Training(trainingData);
trainings.Add(t).GetAwaiter();
trainingTypeData = GetRandom.Object <TrainingTypeData>();
var tt = new TrainingType(trainingTypeData);
types.Add(tt).GetAwaiter();
locationData = GetRandom.Object <LocationData>();
var l = new Location(locationData);
locations.Add(l).GetAwaiter();
obj = new TestClass(coaches, entries, trainings, locations, types);
}
public void Save(string fileName)
{
TrainingData data = new TrainingData();
data.LayerNumber = 2;
data.Rows = new int[grads.Length];
data.Columns = new int[grads.Length];
Matrix matrix = affineLayer01.w;
data.Rows[0] = matrix.X;
data.Columns[0] = matrix.Y;
data.Content.Add(matrix);
matrix = affineLayer01.b;
data.Rows[1] = matrix.X;
data.Columns[1] = matrix.Y;
data.Content.Add(matrix);
matrix = affineLayer02.w;
data.Rows[2] = matrix.X;
data.Columns[2] = matrix.Y;
data.Content.Add(matrix);
matrix = affineLayer02.b;
data.Rows[3] = matrix.X;
data.Columns[3] = matrix.Y;
data.Content.Add(matrix);
data.SaveAsync(fileName);
}
static int PrintCallback(NeuralNet net, TrainingData train, uint max_epochs, uint epochs_between_reports,
float desired_error, uint epochs, Object user_data)
{
Console.WriteLine(String.Format("Epochs " + String.Format("{0:D}", epochs).PadLeft(8) +
". Current Error: " + net.MSE));
return(0);
}
static void Main()
{
const uint num_input = 3;
const uint num_output = 1;
const uint num_layers = 4;
const uint num_neurons_hidden = 5;
const float desired_error = 0.0001F;
const uint max_epochs = 5000;
const uint epochs_between_reports = 1000;
using(NeuralNet net = new NeuralNet(NetworkType.LAYER, num_layers, num_input, num_neurons_hidden, num_neurons_hidden, num_output))
{
net.ActivationFunctionHidden = ActivationFunction.SIGMOID_SYMMETRIC;
net.ActivationFunctionOutput = ActivationFunction.LINEAR;
net.TrainingAlgorithm = TrainingAlgorithm.TRAIN_RPROP;
using (TrainingData data = new TrainingData("..\\..\\..\\datasets\\scaling.data"))
{
net.SetScalingParams(data, -1, 1, -1, 1);
net.ScaleTrain(data);
net.TrainOnData(data, max_epochs, epochs_between_reports, desired_error);
net.Save("..\\..\\..\\datasets\\scaling.net");
Console.ReadKey();
}
}
}
static void Main()
{
const uint num_layers = 3;
const uint num_neurons_hidden = 96;
const float desired_error = 0.001F;
using (TrainingData trainData = new TrainingData("..\\..\\..\\datasets\\robot.train"))
using (TrainingData testData = new TrainingData("..\\..\\..\\datasets\\robot.test"))
{
for (float momentum = 0.0F; momentum < 0.7F; momentum += 0.1F)
{
Console.WriteLine("============= momentum = {0} =============\n", momentum);
using (NeuralNet net = new NeuralNet(NetworkType.LAYER, num_layers, trainData.InputCount, num_neurons_hidden, trainData.OutputCount))
{
net.TrainingAlgorithm = TrainingAlgorithm.TRAIN_INCREMENTAL;
net.LearningMomentum = momentum;
net.TrainOnData(trainData, 20000, 5000, desired_error);
Console.WriteLine("MSE error on train data: {0}", net.TestData(trainData));
Console.WriteLine("MSE error on test data: {0}", net.TestData(testData));
}
}
}
Console.ReadKey();
}
private void WorkerTraining_DoWork(object sender, DoWorkEventArgs e)
{
// Executes when RunWorkerAsync() is called
List <Training> dataReceived = new TrainingData().GetAllEmployeeTraining(); //change for other all
e.Result = dataReceived;
}
public static Training Create(TrainingView v)
{
var d = new TrainingData();
Copy.Members(v, d);
return(new Training(d));
}
public static Domain.Training.Training Create(TrainingView view)
{
var d = new TrainingData();
Copy.Members(view, d);
return(new Domain.Training.Training(d));
}
static int Main(string[] args)
{
int ret = 0;
#if FANN_FIXED
using (NeuralNet net = new NeuralNet("..\\..\\..\\examples\\xor_fixed.net"))
#else
using (NeuralNet net = new NeuralNet("..\\..\\..\\examples\\xor_float.net"))
#endif
{
net.PrintConnections();
net.PrintParameters();
Console.WriteLine("Testing network.");
using (TrainingData data = new TrainingData())
{
#if FANN_FIXED
if (!data.ReadTrainFromFile("..\\..\\..\\examples\\xor_fixed.data"))
#else
if (!data.ReadTrainFromFile("..\\..\\..\\examples\\xor.data"))
#endif
{
Console.WriteLine("Error reading training data --- ABORTING.\n");
return -1;
}
for (int i = 0; i < data.TrainDataLength; i++)
{
net.ResetMSE();
DataType[] calc_out = net.Test(data.GetTrainInput((uint)i).Array, data.GetTrainOutput((uint)i).Array);
#if FANN_FIXED
Console.WriteLine("XOR test ({0}, {1}) - {2}, should be {3}, difference={4}",
data.InputAccessor[i][0], data.InputAccessor[i][0],
calc_out[0], data.OutputAccessor[i][0],
(float) fann_abs(calc_out[0] - data.OutputAccessor[i][0]) / net.Multiplier);
if ((float)fann_abs(calc_out[0] - data.OutputAccessor[i][0]) / net.Multiplier > 0.2)
{
Console.WriteLine("Test failed");
ret = -1;
}
#else
Console.WriteLine("XOR test ({0}, {1}) -> {2}, should be {3}, difference={4}",
data.GetTrainInput((uint)i)[0],
data.GetTrainInput((uint)i)[1],
calc_out[0],
data.GetTrainOutput((uint)i)[0],
calc_out[0] - data.GetTrainOutput((uint)i)[0]);
#endif
}
Console.WriteLine("Cleaning up.");
}
}
Console.ReadKey();
return ret;
}
public void AttachData(IList<TrainingData> trainingData)
{
data = trainingData;
currentData = data.First(x => x.UserScore == null);
currentPosition = data.IndexOf(currentData);
totalData = data.Count;
progressBar.Maximum = totalData;
progressBar.Value = currentPosition;
currentPicture = new Bitmap(currentData.ImagePath).ConvertToGrayScale();
}
static void Main(string[] args)
{
DataType[] calc_out;
const uint num_input = 2;
const uint num_output = 1;
const uint num_layers = 3;
const uint num_neurons_hidden = 3;
const float desired_error = 0;
const uint max_epochs = 1000;
const uint epochs_between_reports = 10;
int decimal_point;
Console.WriteLine("Creating network.");
using (NeuralNet net = new NeuralNet(NetworkType.LAYER, num_layers, num_input, num_neurons_hidden, num_output))
using (TrainingData data = new TrainingData("..\\..\\..\\examples\\xor.data"))
{
net.ActivationFunctionHidden = ActivationFunction.SIGMOID_SYMMETRIC;
net.ActivationFunctionOutput = ActivationFunction.SIGMOID_SYMMETRIC;
net.TrainStopFunction = StopFunction.STOPFUNC_BIT;
net.BitFailLimit = 0.01F;
net.TrainingAlgorithm = TrainingAlgorithm.TRAIN_RPROP;
net.InitWeights(data);
Console.WriteLine("Training network.");
net.TrainOnData(data, max_epochs, epochs_between_reports, desired_error);
Console.WriteLine("Testing network");
// Keep a copy of the inputs and outputs so that we don't call TrainingData.Input
// and TrainingData.Output multiple times causing a copy of all the data on each
// call. An alternative is to use the Input/OutputAccessors which are fast with
// repeated calls to get data and can be cast to arrays with the Array property
DataType[][] input = data.Input;
DataType[][] output = data.Output;
for (int i = 0; i < data.TrainDataLength; i++)
{
calc_out = net.Run(input[i]);
Console.WriteLine("XOR test ({0},{1}) -> {2}, should be {3}, difference={4}",
input[i][0], input[i][1], calc_out[0], output[i][0],
FannAbs(calc_out[0] - output[i][0]));
}
Console.WriteLine("Saving network.\n");
net.Save("..\\..\\..\\examples\\xor_float.net");
decimal_point = net.SaveToFixed("..\\..\\..\\examples\\xor_fixed.net");
data.SaveTrainToFixed("..\\..\\..\\examples\\xor_fixed.data", (uint)decimal_point);
Console.ReadKey();
}
}
static void Main()
{
const uint num_layers = 3;
const uint num_neurons_hidden = 96;
const float desired_error = 0.00007F;
using (TrainingData trainData = new TrainingData())
using (TrainingData testData = new TrainingData())
{
trainData.CreateTrainFromCallback(374, 48, 3, TrainingDataCallback);
testData.CreateTrainFromCallback(594, 48, 3, TestDataCallback);
// Test Accessor classes
for (int i = 0; i < trainData.TrainDataLength; i++)
{
Console.Write("Input {0}: ", i);
for (int j = 0; j < trainData.InputCount; j++)
{
Console.Write("{0}, ", trainData.InputAccessor[i][j]);
}
Console.Write("\nOutput {0}: ", i);
for (int j = 0; j < trainData.OutputCount; j++)
{
Console.Write("{0}, ", trainData.OutputAccessor[i][j]);
}
Console.WriteLine("");
}
for (float momentum = 0.0F; momentum < 0.7F; momentum += 0.1F)
{
Console.WriteLine("============= momentum = {0} =============\n", momentum);
using (NeuralNet net = new NeuralNet(NetworkType.LAYER, num_layers, trainData.InputCount, num_neurons_hidden, trainData.OutputCount))
{
net.SetCallback(TrainingCallback, "Hello!");
net.TrainingAlgorithm = TrainingAlgorithm.TRAIN_INCREMENTAL;
net.LearningMomentum = momentum;
net.TrainOnData(trainData, 20000, 500, desired_error);
Console.WriteLine("MSE error on train data: {0}", net.TestData(trainData));
Console.WriteLine("MSE error on test data: {0}", net.TestData(testData));
}
}
}
Console.ReadKey();
}
static void Main()
{
const uint num_layers = 3;
const uint num_neurons_hidden = 32;
const float desired_error = 0.0001F;
const uint max_epochs = 300;
const uint epochs_between_reports = 10;
Console.WriteLine("Creating network.");
using (TrainingData data = new TrainingData("..\\..\\..\\datasets\\mushroom.train"))
using (NeuralNet net = new NeuralNet(NetworkType.LAYER, num_layers, data.InputCount, num_neurons_hidden, data.OutputCount))
{
Console.WriteLine("Training network.");
net.ActivationFunctionHidden = ActivationFunction.SIGMOID_SYMMETRIC;
net.ActivationFunctionOutput = ActivationFunction.SIGMOID;
net.TrainOnData(data, max_epochs, epochs_between_reports, desired_error);
Console.WriteLine("Testing network.");
using (TrainingData testData = new TrainingData())
{
testData.ReadTrainFromFile("..\\..\\..\\datasets\\mushroom.test");
net.ResetMSE();
for (int i = 0; i < testData.TrainDataLength; i++)
{
// The difference between calling GetTrain[Input|Output] and calling
// the Input and Output properties is huge in terms of speed
net.Test(testData.GetTrainInput((uint)i).Array, testData.GetTrainOutput((uint)i).Array);
}
Console.WriteLine("MSE error on test data {0}", net.MSE);
Console.WriteLine("Saving network.");
net.Save("..\\..\\..\\examples\\mushroom_float.net");
Console.ReadKey();
}
}
}
private static void TrainOnSteepnessFile(NeuralNet net, string filename,
uint max_epochs, uint epochs_between_reports,
float desired_error, float steepness_start,
float steepness_step, float steepness_end)
{
float error;
using (TrainingData data = new TrainingData())
{
data.ReadTrainFromFile(filename);
if (epochs_between_reports != 0)
{
Console.WriteLine("Max epochs {0}. Desired error: {1}", max_epochs.ToString("00000000"), desired_error.ToString("0.0000000000"));
}
net.ActivationSteepnessHidden = steepness_start;
net.ActivationSteepnessOutput = steepness_start;
for (int i = 1; i <= max_epochs; i++)
{
error = net.TrainEpoch(data);
if(epochs_between_reports != 0 && (i % epochs_between_reports == 0 || i == max_epochs || i == 1 || error < desired_error))
{
Console.WriteLine("Epochs {0}. Current error: {1}", i.ToString("00000000"), error.ToString("0.0000000000"));
}
if(error < desired_error)
{
steepness_start += steepness_step;
if(steepness_start <= steepness_end)
{
Console.WriteLine("Steepness: {0}", steepness_start);
net.ActivationSteepnessHidden = steepness_start;
net.ActivationSteepnessOutput = steepness_start;
}
else
{
break;
}
}
}
}
}
static void Main()
{
const uint num_layers = 3;
const uint num_neurons_hidden = 96;
const float desired_error = 0.001F;
Console.WriteLine("Creating network.");
using (TrainingData data = new TrainingData("..\\..\\..\\datasets\\robot.train"))
using (NeuralNet net = new NeuralNet(NetworkType.LAYER, num_layers, data.InputCount, num_neurons_hidden, data.OutputCount))
using (TrainingData testData = new TrainingData())
{
Console.WriteLine("Training network.");
net.TrainingAlgorithm = TrainingAlgorithm.TRAIN_INCREMENTAL;
net.LearningMomentum = 0.4F;
net.TrainOnData(data, 3000, 10, desired_error);
Console.WriteLine("Testing network.");
testData.ReadTrainFromFile("..\\..\\..\\datasets\\robot.test");
try
{
net.ResetMSE();
for (int i = 0; i < testData.TrainDataLength; i++)
{
net.Test(testData.GetTrainInput((uint)i).Array, testData.GetTrainOutput((uint)i).Array);
}
Console.WriteLine("MSE error on test data: {0}", net.MSE);
Console.WriteLine("Saving network.");
net.Save("..\\..\\..\\datasets\\robot_float.net");
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.Message);
}
Console.ReadKey();
}
}
static void Main(string[] args)
{
TrainingData[] xor=new TrainingData[] {
new TrainingData(new double[] {1,0}, new double[] {1}),
new TrainingData(new double[] {0,1}, new double[] {1}),
new TrainingData(new double[] {1,1}, new double[] {0}),
new TrainingData(new double[] {0,0}, new double[] {0}),
};
int[] layers = new int[] { 2,2,1 };
MultilayerPerceptron mlp=new MLPGenerator().Create(layers,1,new Sigmoid());
mlp.Inspector=new SignalInspector();
//shows the neurons processing in VS Output window
mlp.Inspector.Debug=true;
mlp.Inspector.TraceLevel=3;
mlp.LearnFactor=0.9;
var response=mlp.BP(new BPRequest(xor,1000));
Console.ReadKey();
}
static void Main()
{
const uint num_input = 2;
const uint num_output = 1;
const uint num_layers = 3;
const uint num_neurons_hidden = 3;
const float desired_error = 0.001F;
const uint max_epochs = 500000;
const uint epochs_between_reports = 1000;
DataType[] calc_out;
using (TrainingData data = new TrainingData("..\\..\\..\\examples\\xor.data"))
using (NeuralNet net = new NeuralNet(NetworkType.LAYER, num_layers, num_input, num_neurons_hidden, num_output))
{
net.ActivationFunctionHidden = ActivationFunction.SIGMOID_SYMMETRIC;
net.ActivationFunctionOutput = ActivationFunction.SIGMOID_SYMMETRIC;
net.TrainingAlgorithm = TrainingAlgorithm.TRAIN_QUICKPROP;
TrainOnSteepnessFile(net, "..\\..\\..\\examples\\xor.data", max_epochs, epochs_between_reports, desired_error, 1.0F, 0.1F, 20.0F);
net.ActivationFunctionHidden = ActivationFunction.THRESHOLD_SYMMETRIC;
net.ActivationFunctionOutput = ActivationFunction.THRESHOLD_SYMMETRIC;
for(int i = 0; i != data.TrainDataLength; i++)
{
calc_out = net.Run(data.GetTrainInput((uint)i));
Console.WriteLine("XOR test ({0}, {1}) -> {2}, should be {3}, difference={4}",
data.InputAccessor[i][0], data.InputAccessor[i][1], calc_out[0], data.OutputAccessor[i][0],
FannAbs(calc_out[0] - data.OutputAccessor[i][0]));
}
net.Save("..\\..\\..\\examples\\xor_float.net");
Console.ReadKey();
}
}
static int PrintCallback(NeuralNet net, TrainingData train, uint max_epochs, uint epochs_between_reports, float desired_error, uint epochs, Object user_data)
{
Console.WriteLine(String.Format("Epochs " + String.Format("{0:D}", epochs).PadLeft(8) + ". Current Error: " +
String.Format("{0:F}", net.MSE).PadRight(8)));
return 0;
}
public TrainingData OnTraining()
{
if (termeltEgysegekSzama == 4 && playerCount == 2) return null;
if (playerCount <= 3 && myInfo.Money < 100 && !myInfo.Researched.Contains("írás")) return null;
if (myUnits.Count > 20) return null;
if (myInfo.Money >= 50)
{
TrainingData cmd = new TrainingData();
cmd.UnitTypeName = "talpas";
cmd.PositionX = myCities.ElementAt(0).PositionX;
cmd.PositionY = myCities.ElementAt(0).PositionY;
myInfo.Money -= 50;
return cmd;
}
return null;
}
// Test function that demonstrates usage of the fann C++ wrapper
private static void xor_test()
{
System.Console.WriteLine("XOR test started.");
const float LearningRate = 0.7f;
const uint numInput = 2;
const uint numHidden = 3;
const uint numOutput = 1;
const float desired_error = 0;
const uint max_iterations = 1000;
const uint iterations_between_reports = 10;
System.Console.WriteLine("Creating network.");
NeuralNet net = new NeuralNet();
List<uint> layers = new List<uint>();
layers.Add(numInput);
layers.Add(numHidden);
layers.Add(numOutput);
net.CreateStandardArray(layers.ToArray());
net.SetLearningRate(LearningRate);
net.SetActivationSteepnessHidden(1.0);
net.SetActivationSteepnessOutput(1.0);
net.SetActivationFunctionHidden(ActivationFunction.SigmoidSymmetric);
net.SetActivationFunctionOutput(ActivationFunction.SigmoidSymmetric);
net.SetTrainStopFunction(StopFunction.Bit);
net.SetBitFailLimit(0.01f);
// Set additional properties such as the training algorithm
//net.SetTrainingAlgorithm(FANN::TRAIN_QuickProp);
// Output network type and parameters
System.Console.WriteLine("Network Type : ");
switch (net.GetNetworkType())
{
case NetworkType.Layer:
System.Console.WriteLine("LAYER");
break;
case NetworkType.ShortCut:
System.Console.WriteLine("SHORTCUT");
break;
default:
System.Console.WriteLine("UNKNOWN");
break;
}
net.PrintParameters();
System.Console.WriteLine("Training network.");
TrainingData data = new TrainingData();
bool d = data.ReadTrainFromFile("xor.data");
if (d)
{
// Initialize and train the network with the data
net.InitWeights(data);
System.Console.WriteLine("Max Epochs " + max_iterations + ". "
+ "Desired Error: " + desired_error);
net.Callback += (nn, train, max_epochs, epochs_between_reports, de, epochs)
=>
{
System.Console.WriteLine("Epochs " + epochs + ". " + "Current Error: " + nn.GetMSE() + "\n");
return 0;
};
net.TrainOnData(data, max_iterations,
iterations_between_reports, desired_error);
System.Console.WriteLine("Testing network.");
for (uint i = 0; i < data.TrainingDataLength; ++i)
{
// Run the network on the test data
double calcOut = net.Run(data.Input[i])[0];
System.Console.WriteLine("XOR test (" + data.Input[i][0] + ", "
+ data.Input[i][1] + ") -> " + calcOut
+ ", should be " + data.Output[i][0] + ", "
+ "difference = "
+ Math.Abs(calcOut - data.Output[i][0]));
}
System.Console.WriteLine("Saving network.");
// Save the network in floating point and fixed point
net.Save("xor_float.net");
uint decimal_point = (uint)net.SaveToFixed("xor_fixed.net");
data.SaveTrainToFixed("xor_fixed.data", decimal_point);
System.Console.WriteLine("XOR test completed.");
}
else
Console.WriteLine("Training file not found");
}
/// <summary>
/// Metoda tworzenia i uczenia sieci neuronowych.
/// </summary>
/// <param name="maxMaxEpochs">Maksymalna liczba epok.</param>
/// <param name="minMaxEpochs">Minimalna liczba epok.</param>
/// <param name="maxEpochsMultiplierStep">Krok mnożący liczby epok dla kolejnego rodzaju sieci. </param>
/// <param name="minHiddenLayersMultiplier">Minimalny mnożnik dla warstw ukrytych.</param>
/// <param name="maxHiddenLayersMultiplier">Maksymalny mnożnik dla wartw ukrytych.</param>
/// <param name="hiddenLayersMultiplierStep">Krok dodający dla mnożnika warstw ukrytych.</param>
/// <param name="methodProgressPart">Wartość (0 - 100) określająca jaka część postępu inicjalizacji należy do tej metody.</param>
private void CreateNetworks(
string path,
string trainDataFolder,
string testDataFolder,
int maxMaxEpochs,
int minMaxEpochs,
double maxEpochsMultiplierStep,
double minHiddenLayersMultiplier,
double maxHiddenLayersMultiplier,
double hiddenLayersMultiplierStep,
double methodProgressPart,
double desiredMSE
)
{
double methodStartProgress = this.InitializationProgress;
List<TrainingDataFileParameters> fileList = DataProvider.Instance.GetTrainingDataFilesParameters(trainDataFolder);
List<NeuralNetworkParameters> parameters = new List<NeuralNetworkParameters>();
foreach (TrainingDataFileParameters file in fileList)
{
for (double i = minMaxEpochs; i <= maxMaxEpochs; i *= maxEpochsMultiplierStep)
{
for (double j = minHiddenLayersMultiplier; j <= maxHiddenLayersMultiplier; j += hiddenLayersMultiplierStep)
{
parameters.Add(new NeuralNetworkParameters()
{
fileParameters = file,
hiddenLayersMultiplier = j,
maxEpochs = (uint)i
});
}
}
}
int numberOfNetworksToCreate = parameters.Count;
int numberOfCreatedNetworks = 0;
NetworkMSE lowestNetworkMSE = null;
try
{
StringReader reader = new StringReader(File.ReadAllText(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\" + path + "LowestMSENetwork.xml"));
XmlSerializer serializer = new XmlSerializer(typeof(NetworkMSE));
lowestNetworkMSE = (NetworkMSE)serializer.Deserialize(reader);
}
catch
{
lowestNetworkMSE = null;
}
//small hack
if (lowestNetworkMSE != null && lowestNetworkMSE.MSE < desiredMSE)
{
this.InitializationProgress = 100;
return;
}
string[] testFiles = Directory.GetFiles(testDataFolder);
List<TrainingData> testDataList = new List<TrainingData>();
foreach (string testFile in testFiles)
{
TrainingData td = new TrainingData();
//if (td.ReadTrainFromFile(testDataFolder + "\\" + Path.GetFileName(testFile)))
if (td.ReadTrainFromFile(testFile))
{
testDataList.Add(td);
}
}
List<TrainingData> trainingDataList = new List<TrainingData>();
foreach (TrainingDataFileParameters file in fileList)
{
TrainingData td = new TrainingData();
if (td.ReadTrainFromFile(trainDataFolder.Split('\\').Last() + "\\" + file.FileName))
{
trainingDataList.Add(td);
}
}
string initStatus = this.InitializationStatus;
Directory.CreateDirectory(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\" + path);
List<Task> taskList = new List<Task>();
NeuralNet.CallbackType[] callbacksArray = new NeuralNet.CallbackType[this.MaxComputingThreads];
Semaphore threadProgressSemaphore = new Semaphore(1, 1);
Semaphore allSem = new Semaphore(1, 1);
TrainingData[] threadDataVars = new TrainingData[this.MaxComputingThreads];
for (int i = 1; i <= this.MaxComputingThreads; i++)
{
int taskNumber = i;
threadDataVars[i - 1] = new TrainingData();
Task t = new Task((Action)(
() =>
{
while (true)
{
allSem.WaitOne();
if (parameters.Count == 0)
{
this.InitializationStatus = initStatus + " " + numberOfNetworksToCreate.ToString() + " / " + numberOfNetworksToCreate.ToString();
this.InitializationProgress = 100;
break;
}
else
{
NeuralNetworkParameters usedParameters = parameters.First();
parameters.RemoveAt(0);
if (!File.Exists(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\" + path + usedParameters.FileName))
{
NeuralNet net = new NeuralNet();
List<uint> layers = new List<uint>();
layers.Add((uint)((usedParameters.fileParameters.NumberOfPeriods * 2) - 1)); // inputs
layers.Add((uint)(layers[0] * usedParameters.hiddenLayersMultiplier)); // hidden
layers.Add(3); // output
net.CreateStandardArray(layers.ToArray());
net.SetLearningRate((float)0.7);
net.SetActivationFunctionHidden(ActivationFunction.SigmoidSymmetric);
net.SetActivationFunctionOutput(ActivationFunction.SigmoidSymmetric);
net.Callback += callbacksArray[taskNumber - 1];
threadDataVars[taskNumber - 1] = trainingDataList.Find((e) => ((e.NumInputTrainData == layers[0]) && (e.Input.Length == usedParameters.fileParameters.NumberOfPatterns)));
allSem.Release();
net.TrainOnData(threadDataVars[taskNumber - 1],
usedParameters.maxEpochs, // max iterations
0,// iterations between report
0 //desired error
);
allSem.WaitOne();
net.TestData(testDataList.Find((e) => e.NumInputTrainData == layers[0]));
double mse = net.GetMSE();
if (lowestNetworkMSE == null || lowestNetworkMSE.MSE > mse)
{
lowestNetworkMSE = new NetworkMSE()
{
MSE = mse,
NetworkFileName = usedParameters.FileName
};
StringWriter writer = new StringWriter();
XmlSerializer serializer = new XmlSerializer(typeof(NetworkMSE));
serializer.Serialize(writer, lowestNetworkMSE);
File.WriteAllText(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\" + path + "LowestMSENetwork.xml", writer.ToString());
}
net.Save(path + usedParameters.FileName);
}
this.InitializationStatus = initStatus + " " + numberOfCreatedNetworks.ToString() + " / " + numberOfNetworksToCreate.ToString();
numberOfCreatedNetworks++;
this.InitializationProgress = (numberOfCreatedNetworks * methodProgressPart / numberOfNetworksToCreate) + methodStartProgress;
}
allSem.Release();
}
}
), TaskCreationOptions.LongRunning
);
taskList.Add(t);
}
foreach (Task t in taskList)
{
t.Start();
}
}
static void Main()
{
const float desired_error = 0.0F;
uint max_neurons = 30;
uint neurons_between_reports = 1;
uint bit_fail_train, bit_fail_test;
float mse_train, mse_test;
DataType[] output;
DataType[] steepness = new DataType[1];
int multi = 0;
ActivationFunction[] activation = new ActivationFunction[1];
TrainingAlgorithm training_algorithm = TrainingAlgorithm.TRAIN_RPROP;
Console.WriteLine("Reading data.");
using (TrainingData trainData = new TrainingData("..\\..\\..\\datasets\\parity8.train"))
using (TrainingData testData = new TrainingData("..\\..\\..\\datasets\\parity8.test"))
{
trainData.ScaleTrainData(-1, 1);
testData.ScaleTrainData(-1, 1);
Console.WriteLine("Creating network.");
using (NeuralNet net = new NeuralNet(NetworkType.SHORTCUT, 2, trainData.InputCount, trainData.OutputCount))
{
net.TrainingAlgorithm = training_algorithm;
net.ActivationFunctionHidden = ActivationFunction.SIGMOID_SYMMETRIC;
net.ActivationFunctionOutput = ActivationFunction.LINEAR;
net.TrainErrorFunction = ErrorFunction.ERRORFUNC_LINEAR;
if (multi == 0)
{
steepness[0] = 1;
net.CascadeActivationSteepnesses = steepness;
activation[0] = ActivationFunction.SIGMOID_SYMMETRIC;
net.CascadeActivationFunctions = activation;
net.CascadeCandidateGroupsCount = 8;
}
if (training_algorithm == TrainingAlgorithm.TRAIN_QUICKPROP)
{
net.LearningRate = 0.35F;
net.RandomizeWeights(-2.0F, 2.0F);
}
net.BitFailLimit = (DataType)0.9;
net.TrainStopFunction = StopFunction.STOPFUNC_BIT;
net.PrintParameters();
net.Save("..\\..\\..\\examples\\cascade_train2.net");
Console.WriteLine("Training network.");
net.CascadetrainOnData(trainData, max_neurons, neurons_between_reports, desired_error);
net.PrintConnections();
mse_train = net.TestData(trainData);
bit_fail_train = net.BitFail;
mse_test = net.TestData(testData);
bit_fail_test = net.BitFail;
Console.WriteLine("\nTrain error: {0}, Train bit-fail: {1}, Test error: {2}, Test bit-fail: {3}\n",
mse_train, bit_fail_train, mse_test, bit_fail_test);
for (int i = 0; i < trainData.TrainDataLength; i++)
{
output = net.Run(trainData.GetTrainInput((uint)i));
if ((trainData.GetTrainOutput((uint)i)[0] >= 0 && output[0] <= 0) ||
(trainData.GetTrainOutput((uint)i)[0] <= 0 && output[0] >= 0))
{
Console.WriteLine("ERROR: {0} does not match {1}", trainData.GetTrainOutput((uint)i)[0], output[0]);
}
}
Console.WriteLine("Saving network.");
net.Save("..\\..\\..\\examples\\cascade_train.net");
Console.ReadKey();
}
}
}
static void Main()
{
const uint num_layers = 3;
const uint num_neurons_hidden = 32;
const float desired_error = 0.0001F;
const uint max_epochs = 300;
const uint epochs_between_reports = 10;
long before;
Console.WriteLine("Creating network.");
using (TrainingData data = new TrainingData("..\\..\\..\\datasets\\mushroom.train"))
using (NeuralNet net = new NeuralNet(NetworkType.LAYER, num_layers, data.InputCount, num_neurons_hidden, data.OutputCount))
{
Console.WriteLine("Training network.");
net.ActivationFunctionHidden = ActivationFunction.SIGMOID_SYMMETRIC;
net.ActivationFunctionOutput = ActivationFunction.SIGMOID;
net.TrainOnData(data, max_epochs, epochs_between_reports, desired_error);
Console.WriteLine("Testing network.");
using (TrainingData testData = new TrainingData())
{
testData.ReadTrainFromFile("..\\..\\..\\datasets\\mushroom.test");
before = Environment.TickCount;
for (int i = 0; i < 5; i++)
{
DataType[] input = new DataType[testData.InputCount];
DataType[] output = new DataType[testData.OutputCount];
for(int j = 0; j < testData.InputCount; j++)
{
input[j] = testData.InputAccessor[i][j];
}
for (int j = 0; j < testData.OutputCount; j++)
{
output[j] = testData.OutputAccessor[i][j];
}
net.Test(input, output);
}
Console.WriteLine("Data Accessor ticks {0}", Environment.TickCount - before);
before = Environment.TickCount;
for (int i = 0; i < 5; i++)
{
DataType[] input = new DataType[testData.InputCount];
DataType[] output = new DataType[testData.OutputCount];
for (int j = 0; j < testData.InputCount; j++)
{
input[j] = testData.Input[i][j];
}
for (int j = 0; j < testData.OutputCount; j++)
{
output[j] = testData.Output[i][j];
}
net.Test(input, output);
}
Console.WriteLine("Array ticks {0}", Environment.TickCount - before);
}
Console.WriteLine("MSE error on test data {0}", net.MSE);
Console.WriteLine("Saving network.");
net.Save("..\\..\\..\\examples\\mushroom_float.net");
Console.ReadKey();
}
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
words2pos = new Dictionary<string, long>();
wordsOrder = new List<string>();
outputValues = new Dictionary<string, long>();
totalRows = 0;
Invoke(new MethodInvoker(
delegate
{
button1.Enabled = false;
tabControl1.Enabled = false;
}
));
Tuple<string, string> arg = (Tuple<string, string>)e.Argument;
OleDbConnection myOleDbConnection = null;
OleDbCommand myOleDbCommand = null;
OleDbDataReader myOleDbDataReader = null;
StreamWriter outputFile = null;
StreamWriter dictOutputFile = null;
StreamWriter catOutputFile = null;
try
{
string connectionString = "provider=Microsoft.Jet.OLEDB.4.0;data source=" + arg.Item1;
myOleDbConnection = new OleDbConnection(connectionString);
myOleDbCommand = myOleDbConnection.CreateCommand();
// TOP 100
myOleDbCommand.CommandText = "SELECT TOP " + (int)numericUpDown3.Value + " Recept, Content, ReceptDescription,DishType FROM tblMain";
myOleDbConnection.Open();
myOleDbDataReader = myOleDbCommand.ExecuteReader();
int i = 0;
while (myOleDbDataReader.Read())
{
i++;
prepareTrainingData((string)myOleDbDataReader["Content"], (string)myOleDbDataReader["DishType"], 1, null);
if (i % 541 == 0)
{
report("First pass: "******"SELECT TOP " + (int)numericUpDown3.Value + " Recept, Content, ReceptDescription,DishType FROM tblMain";
myOleDbDataReader = myOleDbCommand.ExecuteReader();
outputFile = new StreamWriter(File.OpenWrite(arg.Item2));
outputFile.WriteLine(totalRows + " " + wordsOrder.Count + " " + outputValues.Count);
i = 0;
while (myOleDbDataReader.Read())
{
i++;
prepareTrainingData((string)myOleDbDataReader["Content"], (string)myOleDbDataReader["DishType"], 2, outputFile);
if (i % 541 == 0)
{
report("Second pass: "******"Dict and cat dump");
dictOutputFile = new StreamWriter(File.OpenWrite(arg.Item2 + ".words.dict"));
foreach (string word in wordsOrder)
{
dictOutputFile.WriteLine(word);
}
catOutputFile = new StreamWriter(File.OpenWrite(arg.Item2 + ".words.cat"));
foreach (string val in outputValues.OrderBy(x => x.Value).Select(x => x.Key))
{
catOutputFile.WriteLine(val);
}
report("Creating network");
NeuralNet net = new NeuralNet();
net.SetActivationFunctionHidden(ActivationFunction.SigmoidSymmetric);
net.Callback += new NeuralNet.CallbackType(fannProgress);
uint[] layers = textBox5.Text.Split(new char[] { ',' }).Select(x => UInt32.Parse(x.Trim())).ToArray();
net.CreateStandardArray(layers);
TrainingData data = new TrainingData();
outputFile.Close();
report("Reading data");
data.ReadTrainFromFile(arg.Item2);
report("Doing training");
net.TrainOnData(data, (uint)numericUpDown1.Value, 10, (float)numericUpDown2.Value);
net.Save(arg.Item2 + ".ann");
report("Done training. Saved.");
}
finally
{
if (myOleDbDataReader != null)
myOleDbDataReader.Close();
if (myOleDbCommand != null)
myOleDbCommand.Cancel();
if (myOleDbConnection != null)
myOleDbConnection.Close();
if (outputFile != null)
outputFile.Close();
if (dictOutputFile != null)
dictOutputFile.Close();
if (catOutputFile != null)
catOutputFile.Close();
}
}
//Metodo que recibe un numero correspondiente a un dato y lo carga como input
protected void cargarNumeroComoArrayOutput(int number,ref TrainingData td)
{
PatternProcessingHelper patternHelper = new PatternProcessingHelper();
ArrayList arr = patternHelper.ArrayListFromNumber(number, 9);
int i;
for (i = 0; i <= 8; i++)
{
td.Outputs.Add(arr[i]);
}
}
public TrainingData OnTraining()
{
if (turn > 70) return null;
if (myUnits.Count > myCities.Count * 2 && turn > 20) return null;
if (myInfo.Money >= 50 && myUnits.Count < 1) // train first unit
{
CityInfo city = myCities.ElementAt(0);
TrainingData cmd = new TrainingData();
cmd.PositionX = city.PositionX;
cmd.PositionY = city.PositionY;
cmd.UnitTypeName = (myInfo.Researched.Contains("íjászat")) ? "íjász" : "talpas";
myInfo.Money -= 50;
myUnits.Add(new UnitInfo() { MovementPoints = 2, Owner = PlayerName, PositionX = city.PositionX, PositionY = city.PositionY, UnitTypeName = "talpas" });
return cmd;
}
if (myInfo.Money >= 100)
{
int varos = -1;
for (int i = 0; i < myCities.Count; i++)
{
int unitCount = 0;
CityInfo myCity = myCities.ElementAt(i);
for (int j = 0; j < myUnits.Count; j++)
{
if (myUnits.ElementAt(j).PositionX == myCity.PositionX && myUnits.ElementAt(j).PositionY == myCity.PositionY) unitCount++;
}
int surrounding = 0;
for (int x = Math.Max(0, myCity.PositionX - 3); x < Math.Min(14, myCity.PositionX + 3); x++)
{
for (int y = Math.Max(0, myCity.PositionY - 3); y < Math.Min(14, myCity.PositionY); y++)
{
int enemyCount = 0;
for (int j = 0; j < enemyUnits.Count; j++)
{
UnitInfo enemy = enemyUnits.ElementAt(j);
if (enemy.PositionX == x && enemy.PositionY == y) enemyCount++;
}
surrounding += enemyCount;
}
}
if (unitCount < Math.Max(2, surrounding))
{
varos = i;
break;
}
}
if (varos == -1)
return null;
CityInfo city = myCities.ElementAt(varos);
TrainingData cmd = new TrainingData();
cmd.PositionX = city.PositionX;
cmd.PositionY = city.PositionY;
cmd.UnitTypeName = "lovag";
myInfo.Money -= 100;
myUnits.Add(new UnitInfo() { MovementPoints = 2, Owner = PlayerName, PositionX = city.PositionX, PositionY = city.PositionY, UnitTypeName = "lovag" });
int lovagCtr = 0;
for (int i = 0; i < myUnits.Count; i++)
{
if (myUnits.ElementAt(i).UnitTypeName == "lovag") lovagCtr++;
}
return cmd;
}
if (myInfo.Money >= 50)
{
int varos = -1;
for (int i = 0; i < myCities.Count; i++)
{
int unitCount = 0;
CityInfo myCity = myCities.ElementAt(i);
for (int j = 0; j < myUnits.Count; j++)
{
if (myUnits.ElementAt(j).PositionX == myCity.PositionX && myUnits.ElementAt(j).PositionY == myCity.PositionY) unitCount++;
}
int surrounding = 0;
for (int x = Math.Max(0, myCity.PositionX - 3); x < Math.Min(14, myCity.PositionX + 3); x++)
{
for (int y = Math.Max(0, myCity.PositionY-3); y < Math.Min(14, myCity.PositionY); y++)
{
int enemyCount = 0;
for (int j = 0; j < enemyUnits.Count; j++)
{
UnitInfo enemy = enemyUnits.ElementAt(j);
if (enemy.PositionX == x && enemy.PositionY == y) enemyCount++;
}
surrounding += enemyCount;
}
}
if (unitCount < Math.Max(2,surrounding))
{
varos = i;
break;
}
}
if (varos == -1)
return null;
CityInfo city = myCities.ElementAt(varos);
TrainingData cmd = new TrainingData();
cmd.PositionX = city.PositionX;
cmd.PositionY = city.PositionY;
cmd.UnitTypeName = (myInfo.Researched.Contains("íjászat")) ? "íjász" : "talpas";
myInfo.Money -= 50;
myUnits.Add(new UnitInfo() { MovementPoints = 2, Owner = PlayerName, PositionX = city.PositionX, PositionY = city.PositionY, UnitTypeName = "talpas" });
return cmd;
}
return null;
}
static void XorTest()
{
Console.WriteLine("\nXOR test started.");
const float learning_rate = 0.7f;
const uint num_layers = 3;
const uint num_input = 2;
const uint num_hidden = 3;
const uint num_output = 1;
const float desired_error = 0.001f;
const uint max_iterations = 300000;
const uint iterations_between_reports = 1000;
Console.WriteLine("\nCreating network.");
using (NeuralNet net = new NeuralNet(NetworkType.LAYER, num_layers, num_input, num_hidden, num_output))
{
net.LearningRate = learning_rate;
net.ActivationSteepnessHidden = 1.0F;
net.ActivationSteepnessOutput = 1.0F;
net.ActivationFunctionHidden = ActivationFunction.SIGMOID_SYMMETRIC_STEPWISE;
net.ActivationFunctionOutput = ActivationFunction.SIGMOID_SYMMETRIC_STEPWISE;
// Output network type and parameters
Console.Write("\nNetworkType : ");
switch (net.NetworkType)
{
case NetworkType.LAYER:
Console.WriteLine("LAYER");
break;
case NetworkType.SHORTCUT:
Console.WriteLine("SHORTCUT");
break;
default:
Console.WriteLine("UNKNOWN");
break;
}
net.PrintParameters();
Console.WriteLine("\nTraining network.");
using (TrainingData data = new TrainingData())
{
if (data.ReadTrainFromFile("..\\..\\..\\examples\\xor.data"))
{
// Initialize and train the network with the data
net.InitWeights(data);
Console.WriteLine("Max Epochs " + String.Format("{0:D}", max_iterations).PadLeft(8) + ". Desired Error: " + String.Format("{0:F}", desired_error).PadRight(8));
net.SetCallback(PrintCallback, null);
net.TrainOnData(data, max_iterations, iterations_between_reports, desired_error);
Console.WriteLine("\nTesting network.");
for (uint i = 0; i < data.TrainDataLength; i++)
{
// Run the network on the test data
DataType[] calc_out = net.Run(data.Input[i]);
Console.WriteLine("XOR test ({0}, {1}) -> {2}, should be {3}, difference = {4}",
data.InputAccessor[(int)i][0].ToString("+#;-#"),
data.InputAccessor[(int)i][1].ToString("+#;-#"),
calc_out[0] == 0 ? 0.ToString() : calc_out[0].ToString("+#.#####;-#.#####"),
data.OutputAccessor[(int)i][0].ToString("+#;-#"),
FannAbs(calc_out[0] - data.Output[i][0]));
}
Console.WriteLine("\nSaving network.");
// Save the network in floating point and fixed point
net.Save("..\\..\\..\\examples\\xor_float.net");
uint decimal_point = (uint)net.SaveToFixed("..\\..\\..\\examples\\xor_fixed.net");
data.SaveTrainToFixed("..\\..\\..\\examples\\xor_fixed.data", decimal_point);
Console.WriteLine("\nXOR test completed.");
}
}
}
}
static int TrainingCallback(NeuralNet net, TrainingData data, uint maxEpochs, uint epochsBetweenReports, float desiredError, uint epochs, object userData)
{
System.GC.Collect(); // Make sure nothing's getting garbage-collected prematurely
GC.WaitForPendingFinalizers();
Console.WriteLine("Callback: Last neuron weight: {0}, Last data input: {1}, Max epochs: {2}\nEpochs between reports: {3}, Desired error: {4}, Current epoch: {5}\nGreeting: \"{6}\"",
net.ConnectionArray[net.TotalConnections - 1].Weight, data.InputAccessor.Get((int)data.TrainDataLength - 1, (int)data.InputCount - 1),
maxEpochs, epochsBetweenReports, desiredError, epochs, userData);
return 1;
}
private void button4_Click(object sender, EventArgs e)
{
int fileCount = 0;
for (int i = 1; i < 10; i++)
{
DirectoryInfo di = new DirectoryInfo(@"TrainNeural\\" + i.ToString());
FileInfo[] bmpFiles = di.GetFiles("*.png");
fileCount += bmpFiles.Length;
}
double[,] input = new double[fileCount, 480];
double[,] output = new double[fileCount, 10];
List<string> hashes = new List<string>();
int count = 0;
for (int i = 1; i < 10; i++)
{
DirectoryInfo di = new DirectoryInfo(@"TrainNeural\\" + i.ToString());
FileInfo[] bmpFiles = di.GetFiles("*.png");
foreach (FileInfo fi in bmpFiles)
{
string hash = FileHashSum(fi.FullName);
if (hashes.Contains(hash))
continue;
hashes.Add(hash);
Bitmap bmp = new Bitmap(fi.FullName);
bmp = ImageProcessor.Binarization(bmp, ImageProcessor.OtsuThreshold(bmp));
ImageProcessor.GetNumericView(bmp, ref input, count);
for (int j = 1; j < 10; j++)
{
if (j == i)
output[count, j - 1] = 1;
else
output[count, j - 1] = 0;
}
count++;
}
}
if (File.Exists("TrainingData.tr"))
File.Delete("TrainingData.tr");
string fillTrainFile = count.ToString() + " 480 9" + Environment.NewLine;
for (int i = 0; i < count; i++)
{
for (int x = 0; x < 480; x++)
{
fillTrainFile += input[i, x].ToString();
if (x < 479)
fillTrainFile += " ";
else
fillTrainFile += Environment.NewLine;
}
for (int x = 0; x < 9; x++)
{
fillTrainFile += output[i, x].ToString();
if (x < 8)
fillTrainFile += " ";
else
fillTrainFile += Environment.NewLine;
}
if (i % 40 == 0)
{
File.AppendAllText("TrainingData.tr", fillTrainFile);
fillTrainFile = String.Empty;
}
}
File.AppendAllText("TrainingData.tr", fillTrainFile);
NeuralNet neuralNet = new NeuralNet();
uint[] layers = { 480, 190, 9 };
neuralNet.CreateStandardArray(layers);
neuralNet.RandomizeWeights(-0.1, 0.1);
neuralNet.SetLearningRate(0.7f);
TrainingData trainingData = new TrainingData();
trainingData.ReadTrainFromFile("TrainingData.tr");
switch (comboBox1.SelectedIndex)
{
case 0:
neuralNet.TrainOnData(trainingData, 1000, 0, 0.1f);
break;
case 1:
neuralNet.TrainOnData(trainingData, 1000, 0, 0.05f);
break;
case 2:
neuralNet.TrainOnData(trainingData, 1000, 0, 0.01f);
break;
case 3:
neuralNet.TrainOnData(trainingData, 1000, 0, 0.005f);
break;
case 4:
neuralNet.TrainOnData(trainingData, 1000, 0, 0.001f);
break;
}
neuralNet.Save("NeuralNet.ann");
renewNeural = true;
}
protected TrainingData GetATrainningData(String linea)
{
TrainingData td = new TrainingData();
int i;
for (i = 0; i <= 3; i++)
{
try
{
if (!linea.Split(';')[i].Equals(""))
{
cargarNumeroComoArrayInput(Convert.ToInt32(linea.Split(';')[i]), ref td);
}
}
catch (FormatException e)
{
Console.WriteLine("Input string is not a sequence of digits.");
}
catch (OverflowException e)
{
Console.WriteLine("The number cannot fit in an Int32.");
}
}
cargarNumeroComoArrayOutput(Convert.ToInt32(linea.Split(';')[4]), ref td);
return td;
}
int fannProgress(NeuralNet net, TrainingData train, uint maxEpochs, uint epochsBetweenReports, float desiredError, uint epochs)
{
report("Training: epoch " + epochs + " of " + maxEpochs);
return 0;
}
