/// <summary>
/// Zwaraca odpowiedzi sieci dla
/// danego zbioru testowego
/// </summary>
/// <param name="testSet"></param>
/// <returns></returns>
public int[] Compute(InputDataSet testSet)
{
if (testSet.InputDataSize != network.InputCount)
throw new PerceptronWrapperException("Invalid arguments");
return testSet.InputSet
.Select(input => new BasicMLData(input))
.Select(d => network.Winner(d))
.ToArray();
}
/// <summary>
/// Na podstawie wag sieci zwaraca odpowiedzi dla zbioru testowego
/// </summary>
/// <param name="testSet"></param>
/// <returns></returns>
public double[][] Compute(InputDataSet testSet)
{
if (testSet.InputDataSize != _network.InputCount)
throw new PerceptronWrapperException("Invalid arguments");
List<double[]> answers = new List<double[]>();
foreach(double[] input in testSet.InputSet) {
double[] output = new double[_network.OutputCount];
_network.Compute(input, output);
answers.Add(output);
}
return answers.ToArray();
}
/// <summary>
/// Uczy siec Kohonena z podanymi parametrami.
/// </summary>
/// <param name="learningRate">Początkowy współczynnik nauki.</param>
/// <param name="learningChangeRate">Współczynnik zmiany współczynnika nauki</param>
/// <param name="neighbourhoodRate">Początkowy współczynnik sąsiedztwa.</param>
/// <param name="neighbourhoodChangeRate">Współczynnik zmiany współczynnika sąsiedztwa.</param>
/// <param name="trainIterations">Na ilu przykladach przebiega nauka.</param>
/// <param name="learningSet">Zbiór danych uczących.</param>
public void Train(double learningRate, double learningChangeRate,
double neighbourhoodRate, double neighbourhoodChangeRate,
int trainIterations, InputDataSet learningSet)
{
var basicMlDataSet = new BasicMLDataSet(learningSet.InputSet, null);
INeighborhoodFunction neighborhoodFunc =
new KohonenNeighbourhoodFunction(neighbourhoodRate, rows, columns);
var train = new BasicTrainSOM(network, learningRate, basicMlDataSet, neighborhoodFunc);
IStrategy strategy = new KohonenTrainStrategy(learningChangeRate, neighbourhoodChangeRate);
strategy.Init(train);
train.Strategies.Add(strategy);
train.Iteration(trainIterations);
train.FinishTraining();
}
/// <summary>
///
/// </summary>
/// <param name="learningRate">Stala uczenia (zwykle w okolicach 0.1)</param>
/// <param name="epochNumber">Na ilu wybranych losowo przykladach uczyc siec</param>
/// <param name="momentum">Współczynnik bezwładności.</param>
/// <param name="dataSet">Dane do nauki sieci</param>
public void Train(double learningRate, int epochNumber,
double momentum, InputDataSet dataSet)
{
if (learningRate <= 0.0 || epochNumber <= 0)
throw new PerceptronWrapperException("Invalid arguments");
if (_network.InputCount != dataSet.InputDataSize ||
_network.OutputCount != dataSet.OutputDataSize ||
dataSet.InputDataCount <= 0)
throw new PerceptronWrapperException("Invalid data set size");
IMLDataSet data = new BasicMLDataSet(dataSet.InputSet, dataSet.OutputSet);
var backprop = new Backpropagation(_network, data, learningRate, momentum);
// Uczymy siec za pomoca backpropagation
backprop.Iteration(epochNumber);
// :) - Prosciej sie nie da
}
private static void BuildKohonenNetwork(KohonenNetwokConfig config, string trainFile, string testFile)
{
KohonenWrapper kohonen = new KohonenWrapper(config.Height, config.Width, config.InputSize);
InputDataSet trainData = new InputDataSet(trainFile, config.InputSize);
kohonen.Train(config.InitialLearningRate, config.LearningRateDecayFactor,
config.InitialNeighbourhood, config.NeighbourhoodDecayFactor,
config.Iterations, trainData);
InputDataSet testData = new InputDataSet(testFile, config.InputSize);
int[] classes = kohonen.Compute(testData);
foreach (var i in classes) {
Console.Write("({0}): ", i);
for (int k = 0; k < config.InputSize; k++)
Console.Write("{0:F3} ", kohonen.network.Weights.Data[k][i]);
Console.WriteLine();
}
}
private static void BuildPerceptronNetwork(PerceptronNetworkConfig config, string trainFile, string testFile)
{
PerceptronWrapper perceptron = new PerceptronWrapper(
config.InputSize, config.HiddenLayerSizes, config.OutputSize,
config.UseBIAS, config.Unipolar
);
InputDataSet trainData = new InputDataSet(trainFile, config.InputSize, config.OutputSize);
perceptron.Train(config.LearningRate, config.Iterations, config.Momentum, trainData);
InputDataSet testData = new InputDataSet(testFile, config.InputSize);
double[][] results = perceptron.Compute(testData);
foreach (var outputs in results) {
foreach (var output in outputs) {
Console.Write("{0:F3} ", output);
}
Console.WriteLine();
}
}
