/// <summary>
/// Быстрая проверка памяти на отсутсвие повреждений при прошлой записи
/// и соответствия метадаты памяти загружаемойструктуре
/// </summary>
/// <param name="memoryPath"></param>
/// <param name="networkStructure"></param>
/// <returns>Validity of memory after quick check</returns>
public bool IsValidQuickCheck(string memoryPath, NetworkStructure networkStructure)
{
return(IsFileNotCorrupted(memoryPath) && IsMetaDataEquals(memoryPath, networkStructure));
}
private bool IsMetaDataEquals(string memoryPath, NetworkStructure networkStructure)
{
NetworkStructure readedNetworkStructure = ReadNetworkMetadata(memoryPath);
return(NetworkStructureModelsEquals(readedNetworkStructure, networkStructure));
}
public void TestRProp()
{
// Arrange:
ServiceEvaNN serviceEvaNN = new ServiceEvaNN();
NetworkStructure netStructure = new NetworkStructure
{
InputVectorLength = 2,
NeuronsByLayers = new[] { 23, 15, 1 }
};
TrainingConfiguration trainConfig = new TrainingConfiguration
{
TrainingAlgorithmType = TrainingAlgorithmType.RProp,
StartIteration = 0,
EndIteration = 100,
InputDatasetFilename = "TrainingSetsTest//inputSets.txt",
OutputDatasetFilename = "TrainingSetsTest//outputSets.txt",
MemoryFolder = "MemoryRProp"
};
if (!Directory.Exists("TrainingSetsTest"))
{
Directory.CreateDirectory("TrainingSetsTest");
CreateDataSets(trainConfig);
}
if (File.Exists(trainConfig.MemoryFolder + "//memory.txt"))
{
File.Delete(trainConfig.MemoryFolder + "//memory.txt");
}
bool creatingSucceed = serviceEvaNN.CreateNetwork(trainConfig.MemoryFolder, netStructure);
if (creatingSucceed)
{
serviceEvaNN.Train(trainConfig,
true,
ProcessPriorityClass.Normal,
true);
}
// Asserts:
double tolerance = 0.15;
double[] result0 = serviceEvaNN.Handle(new double[] { 0, 0 });
Assert.IsNotNull(result0);
Assert.AreEqual(0.0, result0[0], tolerance);
double[] result1 = serviceEvaNN.Handle(new double[] { 0, 1 });
Assert.IsNotNull(result1);
Assert.AreEqual(0.0, result1[0], tolerance);
double[] result2 = serviceEvaNN.Handle(new double[] { 1, 0 });
Assert.IsNotNull(result2);
Assert.AreEqual(0.0, result2[0], tolerance);
double[] result3 = serviceEvaNN.Handle(new double[] { 1, 1 });
Assert.IsNotNull(result3);
Assert.AreEqual(1.0, result3[0], tolerance);
}
public WeightsMatricesViewModel(NetworkStructure network)
{
_network = network;
}
static void Main(string[] args)
{
int[] nodesPerLayer = new int[] { 400, 200, 100, 50, 30, 13 };
NetworkStructure networkStructure = new NetworkStructure(nodesPerLayer, new TanHActivation());
Network[] networks = new Network[100];
bool fromFile = false;
fromFile = true;
string fileName = WEIGHTS_FILE;
//Console.Write("Load from file (empty if using no file): ");
//string fileName = Console.ReadLine();
//if(fileName != "")
//{
// fromFile = true;
//}
//else
//{
// fileName = WEIGHTS_FILE;
//}
for (int i = 0; i < networks.Length; i++)
{
if (fromFile)
{
networks[i] = new Network(networkStructure, fileName);
}
else
{
networks[i] = new Network(networkStructure, nodesPerLayer);
}
}
MutateNetworks mutateNetworks = new MutateNetworks(0.05f, 10, 2, nodesPerLayer);
int CurrentGeneration = 1;
//infinite loop for training
for (; ;)
{
Console.WriteLine("generation " + CurrentGeneration++ + ": ");
//testing each networks
for (int i = 0; i < networks.Length; i++)
{
networks[i].ResetFitness();
Console.Write(".");
//testing 130 images
for (int j = 0; j < 130; j++)
{
PositionData evaluatedImage = ImageLoading.LoadImage(j / 10, TRAINIG_DATA_PATH);
float[] output = networks[i].EvaluateNetwork(evaluatedImage.imageInfo);
for (int k = 0; k < output.Length; k++)
{
if (evaluatedImage.expectedResult[k] == 1)
{
networks[i].AddFitness(output[k] * 10);
}
else
{
networks[i].AddFitness(-Math.Abs(output[k]));
}
}
}
}
Network bestNetwork = SortNetworks.GetBestNetwork(networks);
Console.WriteLine();
Console.WriteLine("Fitness: " + bestNetwork.Fitness);
for (int j = 0; j < 13; j++)
{
PositionData evaluatedImage = ImageLoading.LoadImage(j, TRAINIG_DATA_PATH);
float[] output = bestNetwork.EvaluateNetwork(evaluatedImage.imageInfo);
float maxValue = output.Max();
Console.WriteLine(output.ToList().IndexOf(maxValue));
}
bestNetwork.SaveNetwork(fileName);
mutateNetworks.Mutate(networks);
}
}
public MLPWatchdog(NetworkStructure structure, double lo, double hi)
: base(structure, lo, hi)
{
Lo = lo;
Hi = hi;
}
public MLPWatchdog(NetworkStructure structure)
: this(structure, -1, 1)
{
}
public List <double> GenerateEmptyMemoryWeights(NetworkStructure networkStructure)
{
Generator generator = new Generator();
return(generator.GenerateEmptyWeightsVector(networkStructure));
}
public List <double> GenerateMemoryWeights(NetworkStructure networkStructure, Random rnd)
{
Generator generator = new Generator();
return(generator.GenerateWeightsVector(networkStructure, rnd));
}
