public void MulticlassTest1()
{
Accord.Math.Tools.SetupGenerator(0);
Neuron.RandGenerator = new ThreadSafeRandom(0);
int numberOfInputs = 3;
int numberOfClasses = 4;
int hiddenNeurons = 5;
double[][] input =
{
new double[] { -1, -1, -1 }, // 0
new double[] { -1, 1, -1 }, // 1
new double[] { 1, -1, -1 }, // 1
new double[] { 1, 1, -1 }, // 0
new double[] { -1, -1, 1 }, // 2
new double[] { -1, 1, 1 }, // 3
new double[] { 1, -1, 1 }, // 3
new double[] { 1, 1, 1 } // 2
};
int[] labels =
{
0,
1,
1,
0,
2,
3,
3,
2,
};
double[][] outputs = Accord.Statistics.Tools
.Expand(labels, numberOfClasses, -1, 1);
var function = new BipolarSigmoidFunction(2);
var network = new ActivationNetwork(function,
numberOfInputs, hiddenNeurons, numberOfClasses);
new NguyenWidrow(network).Randomize();
var teacher = new LevenbergMarquardtLearning(network);
double error = Double.PositiveInfinity;
for (int i = 0; i < 10; i++)
error = teacher.RunEpoch(input, outputs);
for (int i = 0; i < input.Length; i++)
{
int answer;
double[] output = network.Compute(input[i]);
double response = output.Max(out answer);
int expected = labels[i];
Assert.AreEqual(expected, answer);
}
}
//---------------------------------------------
#region Public Methods
public NetworkContainer CreateNetworkContainer()
{
NetworkContainer neuralNetwork = null;
int[] hiddenLayers = new int[cbHiddenLayerNumber.SelectedIndex];
switch (hiddenLayers.Length)
{
case 0:
break;
case 1:
hiddenLayers[0] = (int)this.nHidden1.Value;
break;
case 2:
hiddenLayers[1] = (int)this.nHidden2.Value;
goto case 1;
case 3:
hiddenLayers[2] = (int)this.nHidden3.Value;
goto case 2;
case 4:
hiddenLayers[3] = (int)this.nHidden4.Value;
goto case 3;
default:
break;
}
IActivationFunction activationFunction = null;
if (this.rbBipolarSigmoid.Checked)
{
activationFunction = new BipolarSigmoidFunction((double)numSigmoidAlpha.Value);
}
else if (this.rbSigmoid.Checked)
{
activationFunction = new SigmoidFunction((double)numSigmoidAlpha.Value);
}
else if (this.rbThreshold.Checked)
{
activationFunction = new ThresholdFunction();
}
neuralNetwork = new NetworkContainer(
tbNetworkName.Text,
m_networkSchema,
activationFunction,
hiddenLayers);
// neuralNetwork.Schema.DataRanges.ActivationFunctionRange = new AForge.DoubleRange((double)numRangeLow.Value, (double)numRangeHigh.Value);
return(neuralNetwork);
}
public ResilientBackpropagationLearningNeuralNetwork(double learningRate, double sigmoidAlphaValue, int inputCount, params int[] neuronCounts)
: this(learningRate, sigmoidAlphaValue)
{
_layerCounts = new[] { inputCount }.Concat(neuronCounts).ToArray();
var activationFunction = new BipolarSigmoidFunction(_sigmoidAlphaValue);
_network = new ActivationNetwork(activationFunction, inputCount, neuronCounts);
_network.Randomize();
}
public EvolutionaryLearningNeuralNetwork(int populationSize, double sigmoidAlphaValue, int inputCount, int neuronCounts)
: this(populationSize, sigmoidAlphaValue)
{
_layerCounts = new[] { inputCount, neuronCounts };
var activationFunction = new BipolarSigmoidFunction(_sigmoidAlphaValue);
_network = new ActivationNetwork(activationFunction, inputCount, neuronCounts);
_network.Randomize();
}
public PerceptronLearningNeuralNetwork(double learningRate, double sigmoidAlphaValue, int inputCount, int neuronCounts)
: this(learningRate, sigmoidAlphaValue)
{
_layerCounts = new[] { inputCount, neuronCounts };
var activationFunction = new BipolarSigmoidFunction(_sigmoidAlphaValue);
_network = new ActivationNetwork(activationFunction, inputCount, neuronCounts);
_network.Randomize();
}
public void TestName()
{
IActivationFunction function = new BipolarSigmoidFunction();
var network = new ActivationNetwork(function,
inputsCount: 2, neuronsCount: new[] { 2, 1 });
var layer = network.Layers[0] as ActivationLayer;
var teacher = new PerceptronLearning(network);
teacher.LearningRate = 0.1;
var input = new double[4][];
input[0] = new[] { 0d, 0d };
input[1] = new[] { 0d, 1d };
input[2] = new[] { 1d, 0d };
input[3] = new[] { 1d, 1d };
var output = new double[4][];
output[0] = new[] { 0d };
output[1] = new[] { 0d };
output[2] = new[] { 0d };
output[3] = new[] { 1d };
//// Iterate until stop criteria is met
double error = double.PositiveInfinity;
double previous;
var needToStop = false;
while (!needToStop)
{
}
do
{
previous = error;
// // Compute one learning iteration
error = teacher.RunEpoch(input, output);
} while (Math.Abs(previous - error) > 0.01);
int[] answers = input.Apply(network.Compute).GetColumn(0).Apply(System.Math.Sign);
//https://github.com/accord-net/framework/blob/development/Samples/Neuro/Perceptron/Applications/OneLayerPerceptron.cs
}
private static void network(double[][] inputs, int[] outputs)
{
// Since we would like to learn binary outputs in the form
// [-1,+1], we can use a bipolar sigmoid activation function
IActivationFunction function = new BipolarSigmoidFunction();
// In our problem, we have 2 inputs (x, y pairs), and we will
// be creating a network with 5 hidden neurons and 1 output:
//
var network = new ActivationNetwork(function,
inputsCount: 2, neuronsCount: new[] { 5, 1 });
// Create a Levenberg-Marquardt algorithm
var teacher = new LevenbergMarquardtLearning(network)
{
UseRegularization = true
};
// Because the network is expecting multiple outputs,
// we have to convert our single variable into arrays
//
var y = outputs.ToDouble().ToJagged();
// Iterate until stop criteria is met
double error = double.PositiveInfinity;
double previous;
do
{
previous = error;
// Compute one learning iteration
error = teacher.RunEpoch(inputs, y);
} while (Math.Abs(previous - error) < 1e-10 * previous);
// Classify the samples using the model
int[] answers = inputs.Apply(network.Compute).GetColumn(0).Apply(System.Math.Sign);
// Plot the results
ScatterplotBox.Show("Expected results", inputs, outputs);
ScatterplotBox.Show("Network results", inputs, answers)
.Hold();
}
public void Learn()
{
const int hiddenNeurons = 5;
var numberOfInputs = GetControllerOutputProperties().Length;
var numberOfClasses = Enum.GetNames(typeof(OutputClass)).Length;
var outputs = Accord.Statistics.Tools.Expand(GetOutputs(), numberOfClasses, -1, 1);
var inputs = GetLearnInputs();
var activationFunction = new BipolarSigmoidFunction(2);
NeuralNetwork = new ActivationNetwork(activationFunction, numberOfInputs, hiddenNeurons, numberOfClasses);
new NguyenWidrow(NeuralNetwork).Randomize();
var teacher = new LevenbergMarquardtLearning(NeuralNetwork);
for (var i = 0; i < 10; i++)
{
teacher.RunEpoch(inputs, outputs);
}
}
private static void BuildNNModel(double[][] trainInput, int[] trainOutput, double[][] testInput, int[] testOutput)
{
double[][] outputs = Accord.Math.Jagged.OneHot(trainOutput);
var function = new BipolarSigmoidFunction(2);
var network = new ActivationNetwork(
new BipolarSigmoidFunction(2),
91,
20,
10
);
var teacher = new LevenbergMarquardtLearning(network);
Console.WriteLine("\n-- Training Neural Network");
int numEpoch = 10;
double error = Double.PositiveInfinity;
for (int i = 0; i < numEpoch; i++)
{
error = teacher.RunEpoch(trainInput, outputs);
Console.WriteLine("* Epoch {0} - error: {1:0.0000}", i + 1, error);
}
Console.WriteLine("");
List <int> inSamplePredsList = new List <int>();
for (int i = 0; i < trainInput.Length; i++)
{
double[] output = network.Compute(trainInput[i]);
int pred = output.ToList().IndexOf(output.Max());
inSamplePredsList.Add(pred);
}
List <int> outSamplePredsList = new List <int>();
for (int i = 0; i < testInput.Length; i++)
{
double[] output = network.Compute(testInput[i]);
int pred = output.ToList().IndexOf(output.Max());
outSamplePredsList.Add(pred);
}
int[] inSamplePreds = inSamplePredsList.ToArray();
int[] outSamplePreds = outSamplePredsList.ToArray();
// Accuracy
double inSampleAccuracy = 1 - new ZeroOneLoss(trainOutput).Loss(inSamplePreds);
double outSampleAccuracy = 1 - new ZeroOneLoss(testOutput).Loss(outSamplePreds);
Console.WriteLine("* In-Sample Accuracy: {0:0.0000}", inSampleAccuracy);
Console.WriteLine("* Out-of-Sample Accuracy: {0:0.0000}", outSampleAccuracy);
// Build confusion matrix
int[][] confMatrix = BuildConfusionMatrix(
testOutput, outSamplePreds, 10
);
System.IO.File.WriteAllLines(
Path.Combine(
@"\\Mac\Home\Documents\c-sharp-machine-learning\ch.8\input-data",
"nn-conf-matrix.csv"
),
confMatrix.Select(x => String.Join(",", x))
);
// Precision Recall
PrintPrecisionRecall(confMatrix);
DrawROCCurve(testOutput, outSamplePreds, 10, "NN");
}
public void MulticlassTest1()
{
Accord.Math.Tools.SetupGenerator(0);
// Suppose we would like to teach a network to recognize
// the following input vectors into 3 possible classes:
//
double[][] inputs =
{
new double[] { 0, 1, 1, 0 }, // 0
new double[] { 0, 1, 0, 0 }, // 0
new double[] { 0, 0, 1, 0 }, // 0
new double[] { 0, 1, 1, 0 }, // 0
new double[] { 0, 1, 0, 0 }, // 0
new double[] { 1, 0, 0, 0 }, // 1
new double[] { 1, 0, 0, 0 }, // 1
new double[] { 1, 0, 0, 1 }, // 1
new double[] { 0, 0, 0, 1 }, // 1
new double[] { 0, 0, 0, 1 }, // 1
new double[] { 1, 1, 1, 1 }, // 2
new double[] { 1, 0, 1, 1 }, // 2
new double[] { 1, 1, 0, 1 }, // 2
new double[] { 0, 1, 1, 1 }, // 2
new double[] { 1, 1, 1, 1 }, // 2
};
int[] classes =
{
0, 0, 0, 0, 0,
1, 1, 1, 1, 1,
2, 2, 2, 2, 2,
};
// First we have to convert this problem into a way that the neural
// network can handle. The first step is to expand the classes into
// indicator vectors, where a 1 into a position signifies that this
// position indicates the class the sample belongs to.
//
double[][] outputs = Accord.Statistics.Tools.Expand(classes, -1, +1);
// Create an activation function for the net
var function = new BipolarSigmoidFunction();
// Create an activation network with the function and
// 4 inputs, 5 hidden neurons and 3 possible outputs:
var network = new ActivationNetwork(function, 4, 5, 3);
// Randomly initialize the network
new NguyenWidrow(network).Randomize();
// Teach the network using parallel Rprop:
var teacher = new ParallelResilientBackpropagationLearning(network);
double error = 1.0;
while (error > 1e-5)
error = teacher.RunEpoch(inputs, outputs);
// Checks if the network has learned
for (int i = 0; i < inputs.Length; i++)
{
double[] answer = network.Compute(inputs[i]);
int expected = classes[i];
int actual; answer.Max(out actual);
Assert.AreEqual(expected, actual, 0.01);
}
}
static void TestAnn2()
{
// Here we will be creating a neural network to process 3-valued input
// vectors and classify them into 4-possible classes. We will be using
// a single hidden layer with 5 hidden neurons to accomplish this task.
//
int numberOfInputs = 3;
int numberOfClasses = 4;
int hiddenNeurons = 5;
// Those are the input vectors and their expected class labels
// that we expect our network to learn.
//
double[][] input =
{
new double[] { -1, -1, -1 }, // 0
new double[] { -1, 1, -1 }, // 1
new double[] { 1, -1, -1 }, // 1
new double[] { 1, 1, -1 }, // 0
new double[] { -1, -1, 1 }, // 2
new double[] { -1, 1, 1 }, // 3
new double[] { 1, -1, 1 }, // 3
new double[] { 1, 1, 1 } // 2
};
int[] labels = { 0, 1, 1, 0, 2, 3, 3, 2 };
// In order to perform multi-class classification, we have to select a
// decision strategy in order to be able to interpret neural network
// outputs as labels. For this, we will be expanding our 4 possible class
// labels into 4-dimensional output vectors where one single dimension
// corresponding to a label will contain the value +1 and -1 otherwise.
double[][] outputs = Accord.Statistics.Tools.Expand(labels, numberOfClasses, -1, 1);
// Next we can proceed to create our network
var function = new BipolarSigmoidFunction(2);
var network = new ActivationNetwork(function, numberOfInputs, hiddenNeurons, numberOfClasses);
// Heuristically randomize the network
new NguyenWidrow(network).Randomize();
// Create the learning algorithm
var teacher = new LevenbergMarquardtLearning(network);
// Teach the network for 10 iterations:
double error = Double.PositiveInfinity;
for (int i = 0; i < 10; i++)
{
error = teacher.RunEpoch(input, outputs);
}
// At this point, the network should be able to
// perfectly classify the training input points.
for (int i = 0; i < input.Length; i++)
{
int answer;
double[] output = network.Compute(input[i]);
//double response = output.Max(out answer);
int expected = labels[i];
// at this point, the variables 'answer' and
// 'expected' should contain the same value.
}
}
public void MulticlassTest1()
{
Accord.Math.Tools.SetupGenerator(0);
// Neuron.RandGenerator = new ThreadSafeRandom(0);
int numberOfInputs = 3;
int numberOfClasses = 4;
int hiddenNeurons = 5;
double[][] input =
{
new double[] { -1, -1, -1 }, // 0
new double[] { -1, 1, -1 }, // 1
new double[] { 1, -1, -1 }, // 1
new double[] { 1, 1, -1 }, // 0
new double[] { -1, -1, 1 }, // 2
new double[] { -1, 1, 1 }, // 3
new double[] { 1, -1, 1 }, // 3
new double[] { 1, 1, 1 } // 2
};
int[] labels =
{
0,
1,
1,
0,
2,
3,
3,
2,
};
double[][] outputs = Accord.Statistics.Tools
.Expand(labels, numberOfClasses, -1, 1);
var function = new BipolarSigmoidFunction(2);
var network = new ActivationNetwork(function,
numberOfInputs, hiddenNeurons, numberOfClasses);
new NguyenWidrow(network).Randomize();
var teacher = new LevenbergMarquardtLearning(network);
double error = Double.PositiveInfinity;
for (int i = 0; i < 10; i++)
{
error = teacher.RunEpoch(input, outputs);
}
for (int i = 0; i < input.Length; i++)
{
int answer;
double[] output = network.Compute(input[i]);
double response = output.Max(out answer);
int expected = labels[i];
Assert.AreEqual(expected, answer);
}
}
public void MulticlassTest1()
{
Accord.Math.Tools.SetupGenerator(0);
// Suppose we would like to teach a network to recognize
// the following input vectors into 3 possible classes:
//
double[][] inputs =
{
new double[] { 0, 1, 1, 0 }, // 0
new double[] { 0, 1, 0, 0 }, // 0
new double[] { 0, 0, 1, 0 }, // 0
new double[] { 0, 1, 1, 0 }, // 0
new double[] { 0, 1, 0, 0 }, // 0
new double[] { 1, 0, 0, 0 }, // 1
new double[] { 1, 0, 0, 0 }, // 1
new double[] { 1, 0, 0, 1 }, // 1
new double[] { 0, 0, 0, 1 }, // 1
new double[] { 0, 0, 0, 1 }, // 1
new double[] { 1, 1, 1, 1 }, // 2
new double[] { 1, 0, 1, 1 }, // 2
new double[] { 1, 1, 0, 1 }, // 2
new double[] { 0, 1, 1, 1 }, // 2
new double[] { 1, 1, 1, 1 }, // 2
};
int[] classes =
{
0, 0, 0, 0, 0,
1, 1, 1, 1, 1,
2, 2, 2, 2, 2,
};
// First we have to convert this problem into a way that the neural
// network can handle. The first step is to expand the classes into
// indicator vectors, where a 1 into a position signifies that this
// position indicates the class the sample belongs to.
//
double[][] outputs = Statistics.Tools.Expand(classes, -1, +1);
// Create an activation function for the net
var function = new BipolarSigmoidFunction();
// Create an activation network with the function and
// 4 inputs, 5 hidden neurons and 3 possible outputs:
var network = new ActivationNetwork(function, 4, 5, 3);
// Randomly initialize the network
new NguyenWidrow(network).Randomize();
// Teach the network using parallel Rprop:
var teacher = new ParallelResilientBackpropagationLearning(network);
double error = 1.0;
while (error > 1e-5)
{
error = teacher.RunEpoch(inputs, outputs);
}
// Checks if the network has learned
for (int i = 0; i < inputs.Length; i++)
{
double[] answer = network.Compute(inputs[i]);
int expected = classes[i];
int actual; answer.Max(out actual);
Assert.AreEqual(expected, actual, 0.01);
}
}
public void Train(IForecastingDataSets datasets)
{
NeedToStop = false;
if (ModelStartRunning != null)
{
ModelStartRunning(this, new ComponentRunEventArgs(datasets));
}
IActivationFunction actFunc = null;
double sigmoidAlphaValue = mAnnModelParameter.SigmoidAlphaValue;
if (mAnnModelParameter.HiddenActivationFunction == fann_activationfunc_enum.FANN_SIGMOID_SYMMETRIC)
{
actFunc = new BipolarSigmoidFunction(sigmoidAlphaValue);
}
else if (mAnnModelParameter.HiddenActivationFunction == fann_activationfunc_enum.FANN_SIGMOID)
{
actFunc = new SigmoidFunction(sigmoidAlphaValue);
}
else if (mAnnModelParameter.HiddenActivationFunction == fann_activationfunc_enum.FANN_THRESHOLD)
{
actFunc = new ThresholdFunction();
}
else
{
actFunc = new BipolarSigmoidFunction(sigmoidAlphaValue);
}
mAnnModelParameter.InputNeuronCount = datasets.InputData[0].Length;
mAnnModelParameter.OutputNeuronCount = datasets.OutputData[0].Length;
int inputsCount = mAnnModelParameter.InputNeuronCount;
int outputsCount = mAnnModelParameter.OutputNeuronCount;
// mAnnModelParameter.HiddenNeuronsCount = new int[1];
// mAnnModelParameter.HiddenNeuronsCount[0] = datasets.InputData[0].Length * 2 + 1;
mAnnModelParameter.HiddenCount = 1;
int[] neuronsCount = new int[mAnnModelParameter.HiddenNeuronsCount.Length + 1];
for (int i = 0; i < mAnnModelParameter.HiddenNeuronsCount.Length; i++)
{
neuronsCount[i] = mAnnModelParameter.HiddenNeuronsCount[i];
}
neuronsCount[mAnnModelParameter.HiddenNeuronsCount.Length] = outputsCount;
mNetwork = new ActivationNetwork(actFunc, inputsCount, neuronsCount);
BackPropagationLearning teacher = new BackPropagationLearning(mNetwork);
ActivationLayer layer = mNetwork[0];
teacher.LearningRate = mAnnModelParameter.LearningRate;
teacher.Momentum = mAnnModelParameter.LearningMomentum;
List <double> arError = new List <double>();
int solutionSize = datasets.InputData.Length;
datasets.ForecastedData = new double[solutionSize][];
int iteration = 1;
while (!mNeedToStop)
{
double error = teacher.RunEpoch(datasets.InputData, datasets.OutputData);
arError.Add(error);
double learningError = 0.0;
double predictionError = 0.0;
for (int i = 0, n = solutionSize; i < n; i++)
{
datasets.ForecastedData[i] = (double[])mNetwork.Compute(datasets.InputData[i]).Clone();
if (i >= n - mAnnModelParameter.MaximumWindowSize)
{
predictionError += Math.Abs(datasets.OutputData[i][0] - datasets.ForecastedData[i][0]);
}
else
{
learningError += Math.Abs(datasets.OutputData[i][0] - datasets.ForecastedData[i][0]);
}
}
if (iteration >= mAnnModelParameter.Iterations)
{
NeedToStop = true;
}
if (learningError <= mAnnModelParameter.DesiredError)
{
NeedToStop = true;
}
if (ModelRunningEpoch != null)
{
ModelRunningEpoch(this, new AnnModelRunEpochEventArgs(iteration, error));
}
iteration++;
}
LayerWeightCollection = new LayerWeight[mNetwork.LayersCount];
LayerWeightCollection[0].Weight = new double[layer.NeuronsCount][];
LayerWeightCollection[0].ThreashHold = new double[layer.NeuronsCount][];
for (int i = 0; i < layer.NeuronsCount; i++)
{
LayerWeightCollection[0].Weight[i] = new double[layer.InputsCount];
LayerWeightCollection[0].ThreashHold[i] = new double[layer.InputsCount];
for (int j = 0; j < layer.InputsCount; j++)
{
LayerWeightCollection[0].Weight[i][j] = layer[i][j];
LayerWeightCollection[0].ThreashHold[i][j] = layer[i][j];
}
}
layer = mNetwork[1];
LayerWeightCollection[1].Weight = new double[layer.NeuronsCount][];
LayerWeightCollection[1].ThreashHold = new double[layer.NeuronsCount][];
for (int i = 0; i < layer.NeuronsCount; i++)
{
LayerWeightCollection[1].Weight[i] = new double[layer.InputsCount];
LayerWeightCollection[1].ThreashHold[i] = new double[layer.InputsCount];
for (int j = 0; j < layer.InputsCount; j++)
{
LayerWeightCollection[1].Weight[i][j] = layer[i][j];
LayerWeightCollection[1].ThreashHold[i][j] = layer[i][j];
}
}
if (ModelFinishRunning != null)
{
ModelFinishRunning(this, new ComponentRunEventArgs(datasets));
}
}
static void Main(string[] args)
{
// Read the Excel worksheet into a DataTable
DataTable table = new ExcelReader("examples.xls").GetWorksheet("Classification - Yin Yang");
// Convert the DataTable to input and output vectors
double[][] inputs = table.ToJagged <double>("X", "Y");
int[] outputs = table.Columns["G"].ToArray <int>();
// Since we would like to learn binary outputs in the form
// [-1,+1], we can use a bipolar sigmoid activation function
IActivationFunction function = new BipolarSigmoidFunction();
Console.Write("Enter network name: ");
string networkName = Console.ReadLine();
Network network = null;
if (File.Exists(networkName))
{
network = Network.Load(networkName);
}
else
{
network = new ActivationNetwork(function,
inputsCount: 2, neuronsCount: new[] { 10, 5, 1 });
}
// Create a Levenberg-Marquardt algorithm
var teacher = new LevenbergMarquardtLearning((ActivationNetwork)network)
{
UseRegularization = true
};
// Because the network is expecting multiple outputs,
// we have to convert our single variable into arrays
double[][] y = outputs.ToDouble().ToJagged();
// Iterate until stop criteria is met
double error = double.PositiveInfinity;
double previous;
Dictionary <int, double> epochError = new Dictionary <int, double>();
int currentEpoch = 1;
do
{
previous = error;
// Compute one learning iteration
error = teacher.RunEpoch(inputs, y);
epochError.Add(currentEpoch++, error);
} while (Math.Abs(previous - error) > 0.001);
network.Save(networkName);
// Classify the samples using the model
double[] decimalAnswers = inputs.Apply(network.Compute).GetColumn(0); // can be used as probability.
int[] answers = decimalAnswers.Apply(Math.Sign);
// Plot the results
ScatterplotBox.Show("Expected results", inputs, outputs);
ScatterplotBox.Show("Network results", inputs, answers);
PlotError("Training error", epochError);
}
static void Main()
{
Console.WriteLine("Создание нейронной сети...");
DataItem data = DataItemFactory.GetNumericData();
int inputCount = data.Input.First().Length;
var neuronCount = new[] { 10 };
IActivationFunction function = new BipolarSigmoidFunction();
double learningRate = 0.1;
double momentum = 0;
int maxEpochNumber = 1000000;
double minErrorChange = 0.000001;
double minError = 0.001;
var network = MultilayerNeuralNetwork.CreateNetwork(neuronCount, inputCount, function);
network.Randomize();
Console.WriteLine("Создание нейронной сети завершено.");
var teacher = new PerceptronLearning(network)
{
LearningRate = learningRate
};
int epochNumber = 1;
double lastError = double.MaxValue;
double error;
double errorChange;
Console.WriteLine("Start learning...");
do
{
DateTime dtStart = DateTime.Now;
error = teacher.RunEpoch(data.Input, data.Output) / data.Input.Length;
Console.WriteLine(
$"Epoch #{epochNumber} finished; " +
$"current error is {error}; " +
$"it takes: {(DateTime.Now - dtStart).Duration()}");
errorChange = Math.Abs(lastError - error);
lastError = error;
epochNumber++;
}while (epochNumber < maxEpochNumber &&
error > minError &&
errorChange > minErrorChange);
for (int i = 0; i < data.Input.Length; i++)
{
double[] outputs = network.Compute(data.Input[i]);
string strIn = "";
foreach (var input in data.Output[i])
{
strIn += $"{input},";
}
string strOut = "";
foreach (var output in outputs)
{
strOut += $"{Math.Abs(output):0.00},";
}
Console.WriteLine($"{i}. Expected {strIn} Actual {strOut}");
}
}
public bool Train()
{
if (type == ClassifierType.SVM)
{
if (trainData != null)
{
float[,] mat = trainData.Data;
double[][] inputs = new double[trainData.Rows][];
for (int i = 0; i < trainData.Rows; i++)
{
int numFeatures = Math.Max(trainData.Cols, 2);
inputs[i] = new double[numFeatures];
for (int j = 0; j < numFeatures; j++)
{
inputs[i][j] = mat[i, Math.Min(trainData.Cols - 1, j)];
}
}
int[] outputs = new int[trainLabels.Rows];
for (int i = 0; i < trainLabels.Rows; i++)
{
outputs[i] = trainLabels[i, 0];
}
int numClasses = nameForID.Count;
if (numClasses <= 1)
{
return(true);
}
IKernel kernel;
switch (kernelType)
{
case KernelType.Linear:
kernel = new Linear();
break;
case KernelType.Poly:
kernel = new Polynomial(3);
break;
case KernelType.Rbf:
if (inputs.Length < 20)
{
kernel = new Gaussian(0.1);
}
else
{
kernel = Gaussian.Estimate(inputs, inputs.Length / 4);
}
break;
case KernelType.Chi2:
kernel = new ChiSquare();
break;
default:
kernel = inputs[0].Length > 20 ? (IKernel)(new ChiSquare()) : (IKernel)(Gaussian.Estimate(inputs, inputs.Length / 4));
break;
}
svm = new MulticlassSupportVectorMachine(inputs: inputs[0].Length, kernel: kernel, classes: numClasses);
var teacher = new MulticlassSupportVectorLearning(svm, inputs, outputs)
{
Algorithm = (machine, classInputs, classOutputs, i, j) => new SequentialMinimalOptimization(machine, classInputs, classOutputs)
{
Tolerance = 1e-6,
UseComplexityHeuristic = true
//Tolerance = 0.001,
//Complexity = 1,
//CacheSize = 200
}
};
try
{
double error = teacher.Run();
}
catch (Exception ex) { Debug.WriteLine("Error training SVM: " + ex.Message); }
teacher = new MulticlassSupportVectorLearning(svm, inputs, outputs)
{
Algorithm = (machine, classInputs, classOutputs, i, j) => new ProbabilisticOutputCalibration(machine, classInputs, classOutputs)
};
try
{
double error = teacher.Run();
}
catch (Exception ex) { Debug.WriteLine("Error calibrating SVM: " + ex.Message); }
return(true);
}
return(false);
}
else if (type == ClassifierType.NeuralNet)
{
float[,] mat = trainData.Data;
double[][] inputs = new double[trainData.Rows][];
List <int> randomOrder = new List <int>(trainData.Rows);
for (int i = 0; i < trainData.Rows; i++)
{
randomOrder.Add(i);
}
randomOrder.Shuffle();
for (int i = 0; i < trainData.Rows; i++)
{
inputs[randomOrder[i]] = new double[trainData.Cols];
for (int j = 0; j < trainData.Cols; j++)
{
inputs[randomOrder[i]][j] = mat[i, j];
}
}
int[] classes = new int[trainLabels.Rows];
for (int i = 0; i < trainLabels.Rows; i++)
{
classes[randomOrder[i]] = trainLabels[i, 0];
}
// First we have to convert this problem into a way that the neural
// network can handle. The first step is to expand the classes into
// indicator vectors, where a 1 into a position signifies that this
// position indicates the class the sample belongs to.
//
double[][] outputs = Accord.Statistics.Tools.Expand(classes, -1, +1);
// Create an activation function for the net
var function = new BipolarSigmoidFunction();
// Create an activation network with the function and
// N inputs, (M+N)/2 hidden neurons and M possible outputs:
int N = inputs[0].Length;
int M = nameForID.Count;
network = new ActivationNetwork(function, N, (M + N) / 2, M);
// Randomly initialize the network
new NguyenWidrow(network).Randomize();
// Teach the network using parallel Rprop:
var teacher = new ParallelResilientBackpropagationLearning(network);
double error = 1.0;
int iter = 0;
while (error > 1e-7 && iter < 100)
{
//for (int iter = 0; iter < 10000 && error > 1e-5; iter++)
error = teacher.RunEpoch(inputs, outputs);
iter++;
}
return(true);
}
else if (type == ClassifierType.KMeans)
{
List <double[]> rows = new List <double[]>();
float[,] data = trainData.Data;
for (int i = 0; i < trainData.Rows; i++)
{
double[] row = new double[trainData.Cols];
for (int j = 0; j < trainData.Cols; j++)
{
row[j] = data[i, j];
}
rows.Add(row);
}
double[][] points = rows.ToArray();
kmeans = new Accord.MachineLearning.KMeans(nameForID.Count * 2);
int[] labels = kmeans.Compute(points);
clusterClasses = new Dictionary <int, Dictionary <int, int> >();
for (int i = 0; i < labels.Length; i++)
{
if (!clusterClasses.ContainsKey(labels[i]))
{
clusterClasses.Add(labels[i], new Dictionary <int, int>());
}
int label = trainLabels.Data[i, 0];
if (!clusterClasses[labels[i]].ContainsKey(label))
{
clusterClasses[labels[i]].Add(label, 0);
}
clusterClasses[labels[i]][label]++;
}
return(true);
}
else
{
return(true);
}
}