void Clustering()
{
pca = new PrincipalComponentAnalysis();
//pca
pca.Learn(inputImgArray.ToArray());
var pcaRes = pca.Transform(inputImgArray.ToArray());
dn = new DistanceNetwork(pcaRes[0].Length, mainForm.closestSquareNumber(totalData));
som = new SOMLearning(dn);
Console.WriteLine("Learning");
for (var i = 0; i < maxEpoch; i++)
{
var error = som.RunEpoch(pcaRes);
if (error < errorGoal)
{
break;
}
if (i % 10 == 0)
{
Console.WriteLine($"Report Cluster error {i} : {error}");
}
}
dn.Save(savedDNNetwork);
}
public void somTraining()
{
double[][] input_data = new double[Data.instance.images.Count][];
for (int i = 0; i < images.Count; i++)
{
Bitmap image = new Bitmap(images[i]);
image = preProcess(image);
ImageToArray converter = new ImageToArray(0, 1);
converter.Convert(image, out input_data[i]);
}
pca = new PrincipalComponentAnalysis(PrincipalComponentMethod.Center);
pca.Learn(input_data);
double[][] input_pca = pca.Transform(input_data);
//o Clusters(Groups) Count: 4
som_network = new DistanceNetwork(input_pca[0].Count(), 4);
som_learning = new SOMLearning(som_network);
//o Error Goals: 0.001
//o Max Epochs: 100000
int maxIter = 100000;
double maxError = 0.001;
for (int i = 0; i < maxIter; i++)
{
double error = som_learning.RunEpoch(input_pca);
if (error < maxError)
{
break;
}
}
System.Windows.Forms.MessageBox.Show("SOM Training Complete");
}
static DistanceNetwork CreateSOM(string tagname)
{
int samples = 2 * 31 * 24;
int retro = 3;
var context = new TagDbContext();
var data = context.TagValues
.Where(t => t.Tag.TagName == tagname)
.OrderByDescending(v => v.DateTime)
.Select(v => new double[] { (double)v.DateTime.Hour, (double)v.DateTime.DayOfWeek, v.Value })
.Take(samples + retrospective + 3)
.AsEnumerable()
.Reverse()
.ToArray();
double[][] trainingSet = new double[data.Length][];
for (int index = 0; index < samples; index++)
{
trainingSet[index] = new double[] { data[index + 3][0], data[index + 3][1], data[index + 3][2],
data[index + 2][2], data[index + 1][2], data[index][2] };
}
var networkSize = 15;
var iterations = 500;
var learningRate = 0.3;
var learningRadius = 3;
Neuron.RandRange = new Range(0, 255);
// create network
DistanceNetwork network = new DistanceNetwork(2, networkSize * networkSize);
// create learning algorithm
SOMLearning trainer = new SOMLearning(network, networkSize, networkSize);
// create map
//map = new int[networkSize, networkSize, 3];
double fixedLearningRate = learningRate / 10;
double driftingLearningRate = fixedLearningRate * 9;
// iterations
int i = 0;
// loop
while (true)
{
trainer.LearningRate = driftingLearningRate * (iterations - i) / iterations + fixedLearningRate;
trainer.LearningRadius = (double)learningRadius * (iterations - i) / iterations;
// run training epoch
trainer.RunEpoch(trainingSet);
// increase current iteration
i++;
// stop ?
if (i >= iterations)
{
break;
}
}
return(network);
}
public void DistanceNetworkTest1()
{
string basePath = Path.Combine(NUnit.Framework.TestContext.CurrentContext.TestDirectory, "dn");
#region doc_example
// Assure results are reproducible
Accord.Math.Tools.SetupGenerator(0);
int numberOfInputs = 3;
int hiddenNeurons = 25;
// Create some example inputs
double[][] input =
{
new double[] { -1, -1, -1 },
new double[] { -1, 1, -1 },
new double[] { 1, -1, -1 },
new double[] { 1, 1, -1 },
new double[] { -1, -1, 1 },
new double[] { -1, 1, 1 },
new double[] { 1, -1, 1 },
new double[] { 1, 1, 1 },
};
// Create a new network
var network = new DistanceNetwork(numberOfInputs, hiddenNeurons);
// Create a teaching algorithm
var teacher = new SOMLearning(network);
// Use the teacher to learn the network
double error = Double.PositiveInfinity;
for (int i = 0; i < 10; i++)
{
error = teacher.RunEpoch(input);
}
string fileName = Path.Combine(basePath, "ann.bin");
// Save the network to a file path:
Serializer.Save(network, fileName);
// Load the network back from the stream
DistanceNetwork target = Serializer.Load <DistanceNetwork>(fileName);
#endregion
// Make sure the network we loaded is exactly the same
Assert.AreEqual(network.InputsCount, target.InputsCount);
for (int i = 0; i < network.Layers.Length; i++)
{
Assert.AreEqual(network.Layers[i].InputsCount, target.Layers[i].InputsCount);
for (int j = 0; j < network.Layers[i].Neurons.Length; j++)
{
Assert.AreEqual(network.Layers[i].Neurons[j].InputsCount, target.Layers[i].Neurons[j].InputsCount);
Assert.AreEqual(network.Layers[i].Neurons[j].Weights, target.Layers[i].Neurons[j].Weights);
}
}
}
// Worker thread
void SearchSolution()
{
// create network
DistanceNetwork network = new DistanceNetwork(2, networkSize * networkSize);
// set random generators range
foreach (var layer in network.Layers)
{
foreach (var neuron in layer.Neurons)
{
neuron.RandGenerator = new UniformContinuousDistribution(
new Range(0, Math.Max(pointsPanel.ClientRectangle.Width, pointsPanel.ClientRectangle.Height)));
}
}
// create learning algorithm
SOMLearning trainer = new SOMLearning(network, networkSize, networkSize);
// create map
map = new int[networkSize, networkSize, 3];
double fixedLearningRate = learningRate / 10;
double driftingLearningRate = fixedLearningRate * 9;
// iterations
int i = 0;
// loop
while (!needToStop)
{
trainer.LearningRate = driftingLearningRate * (iterations - i) / iterations + fixedLearningRate;
trainer.LearningRadius = (double)learningRadius * (iterations - i) / iterations;
// run training epoch
trainer.RunEpoch(trainingSet);
// update map
UpdateMap(network);
// increase current iteration
i++;
// set current iteration's info
SetText(currentIterationBox, i.ToString());
// stop ?
if (i >= iterations)
{
break;
}
}
// enable settings controls
EnableControls(true);
}
private void btnTraining_Click(object sender, EventArgs e)
{
double[][] input_data = new double[Data.getInstance().images.Count][];
double[][] output_data = new double[Data.getInstance().images.Count][];
int max = Data.getInstance().classes.Count - 1;
int min = 0;
for (int i = 0; i < Data.getInstance().images.Count; i++)
{
Bitmap image = Data.getInstance().preprocessing(Data.getInstance().images[i]);
ImageToArray converter = new ImageToArray(0, 1);
converter.Convert(image, out input_data[i]);
output_data[i] = new double[1];
output_data[i][0] = Data.getInstance().class_indexes[i];
output_data[i][0] = 0 + (output_data[i][0] - min) * (1 - 0) / (max - min);
}
pca = new PrincipalComponentAnalysis();
pca.Method = PrincipalComponentMethod.Center;
pca.Learn(input_data);
double[][] input_from_pca = pca.Transform(input_data);
int a = 0;
int output_count = 0;
while (a < Data.getInstance().classes.Count)
{
output_count = a * a;
a++;
}
som_network = new DistanceNetwork(input_from_pca[0].Count(), output_count);
som_learning = new SOMLearning(som_network);
int max_iteration = 10000;
double max_error = 0.0001;
for (int i = 0; i < max_iteration; i++)
{
double error = som_learning.RunEpoch(input_from_pca);
if (error < max_error)
{
break;
}
}
btnBrowseClustering.Enabled = true;
btnTraining.Enabled = false;
}
// Worker thread
void SearchSolution( )
{
// set random generators range
Neuron.RandRange = new DoubleRange(0, Math.Max(this.pointsPanel.ClientRectangle.Width, this.pointsPanel.ClientRectangle.Height));
// create network
var network = new DistanceNetwork(2, this.networkSize * this.networkSize);
// create learning algorithm
var trainer = new SOMLearning(network, this.networkSize, this.networkSize);
// create map
this.map = new int[this.networkSize, this.networkSize, 3];
var fixedLearningRate = this.learningRate / 10;
var driftingLearningRate = fixedLearningRate * 9;
// iterations
var i = 0;
// loop
while (!this.needToStop)
{
trainer.LearningRate = driftingLearningRate * (this.iterations - i) / this.iterations + fixedLearningRate;
trainer.LearningRadius = (double)this.learningRadius * (this.iterations - i) / this.iterations;
// run training epoch
trainer.RunEpoch(this.trainingSet);
// update map
UpdateMap(network);
// increase current iteration
i++;
// set current iteration's info
this.currentIterationBox.Text = i.ToString( );
// stop ?
if (i >= this.iterations)
{
break;
}
}
// enable settings controls
EnableControls(true);
}
/// <summary>
/// Override the Epoch() method
/// </summary>
/// <param name="trainingSet"></param>
/// <param name="modalitiesMeanSquarredError"></param>
/// <param name="globalMeanSquarred"></param>
public override void Epoch(List <Dictionary <Signal, double[, ]> > trainingSet, out Dictionary <Signal, double> modalitiesMeanSquarredError, out double globalMeanSquarred)
{
//Convert to Accord format
double[][] samples = new double[trainingSet.Count][];
for (int i = 0; i < trainingSet.Count; i++)
{
samples[i] = concatenateTrainingSample(trainingSet[i]);
}
//Epoch
teacher.RunEpoch(samples);
//Run manually a base class epoch without learning to have the exact same error measurement as other algos
learningLocked = true;
base.Epoch(trainingSet, out modalitiesMeanSquarredError, out globalMeanSquarred);
learningLocked = false;
}
/// <summary>
/// Trains Network for Clustering (Distance Network, Self Organizing Map)
/// </summary>
/// <param name="epoch">Number of epoch</param>
/// <returns>Neural network Error</returns>
// TODO: Build the correct clustering network
public double TrainClusteringNetwork(int epoch = 10000)
{
_clusteringNetwork = CreateNewDistanceNetwork();
var pcaResult = ComputePca(RemoveFromCategory(_allData.Values.ToList()));
var trainer = new SOMLearning(_clusteringNetwork);
var error = 0d;
for (var i = 0; i < epoch; i++)
{
error = trainer.RunEpoch(pcaResult);
if (error < 0.0001)
{
break;
}
}
return(error);
}
private void button1_Click(object sender, EventArgs e)
{
trainer.LearningRate = driftingLearningRate * (iterations - _i) / iterations + fixedLearningRate;
trainer.LearningRadius = (double)learningRadius * (iterations - _i) / iterations;
// run training epoch
trainer.RunEpoch(trainingSet);
// update map
UpdateMap(network);
// increase current iteration
_i++;
// set current iteration's info
currentIterationBox.Text = _i.ToString();
// stop ?
}
public NeuralNetwork Train(SOMTrainerArgs X)
{
if (!Info.Moduls.Contains("NeuralNetworks/Learning/SOMLearnig.cs"))
{
Info.Moduls.Add("NeuralNetworks/Learning/SOMLearnig.cs");
}
SOMLearning Trainer =
new SOMLearning(X.NetworkToTrain.DNetwork);
Trainer.LearningRadius = (X.LearningRadius <= 0) ? (5) : (X.LearningRadius);
Trainer.LearningRate = (X.LearningRate <= 0) ? (0.01) : (X.LearningRate);
uint tick = Settings.LearningUpdateTick;
while (true)
{
double Error = Trainer.RunEpoch(X.Inputs);
if (Error <= X.WantedERROR)
{
break;
}
if (tick == 0)
{
Settings.OnUpdateEvent(this, new LearningUpdateArgs()
{
ERROR = Error,
Inputs = X.Inputs,
Outputs = null,
NetworkState = X.NetworkToTrain,
});
}
else
{
tick--;
}
}
return(X.NetworkToTrain);
}
public Browse()
{
InitializeComponent();
if (listView1.Items.Count == 0)
{
MessageBox.Show("Add some art first");
}
else
{
OpenFileDialog dialog = new OpenFileDialog();
dialog.Multiselect = true;
List <double[]> PCAInput = new List <double[]>();
if (dialog.ShowDialog() == DialogResult.OK)
{
for (int i = 0; i < dialog.FileNames.Length; i++)
{
Bitmap image = new Bitmap(dialog.FileNames.ElementAt(i));
image = preprocessImage(image);
double[] output;
ImageToArray converter = new ImageToArray();
converter.Convert(image, out output);
PCAInput.Add(output);
pca = new PrincipalComponentAnalysis(PCAInput.ToArray());
pca.Compute();
}
}
dn = new DistanceNetwork(pca.Result.GetLength(0), 4);
som = new SOMLearning(dn);
double[][] inputSOM = new double[pca.Result.GetLength(0)][];
for (int i = 0; i < pca.Result.GetLength(1); i++)
{
inputSOM[i] = new double[pca.Result.GetLength(1)];
for (int j = 0; j < pca.Result.GetLength(1); j++)
{
inputSOM[i][j] = pca.Result[i, j];
}
}
//training som
int epoch = 10000;
double minError = 0.0000001;
for (int i = 0; i < epoch; i++)
{
double error = som.RunEpoch(inputSOM);
if (error < minError)
{
break;
}
}
//clustering
for (int i = 0; i < pca.Result.GetLength(0); i++)
{
dn.Compute(inputSOM[i].ToArray());
int winner = dn.GetWinner();
ListViewGroup group;
if (listView1.Groups[winner.ToString()] == null)
{
//bkin group baru
group = new ListViewGroup(winner.ToString(), "" + winner);
}
else
{
//masukin ke group lama
group = listView1.Groups[winner.ToString()];
}
listView1.Groups.Add(group);
//listView1.Items.Add(new ListViewItem(dialog.SafeFileNames[i], i, group));
//imageList1.Images.Add(new Bitmap(dialog.FileNames.ElementAt(i)));
}
}
}
private void somLearningProcessing()
{
// PCA.GetLength(1) means that first dimension is column and zero dimension is row
// neuronsCount must square root of 2
// Find nearest square with total images
int sqrt = (int)Math.Ceiling(Math.Sqrt(listImages.Count));
if (sqrt <= 1)
{
sqrt = 2;
}
// SOMBrain.net doesn't exist && user doesn't add some art
if (Network.loadDistanceNetwork == null && !Network.checkAddArt)
{
Network.distanceNetwork = new DistanceNetwork(principalComponentAnalysis.Result.GetLength(1), (int)Math.Pow(sqrt, 2));
somLearning = new SOMLearning(Network.distanceNetwork);
}
// SOMBrain.net doest exist && user add some art
else if (Network.loadDistanceNetwork != null && Network.checkAddArt)
{
Network.distanceNetwork = new DistanceNetwork(principalComponentAnalysis.Result.GetLength(1), (int)Math.Pow(sqrt, 2));
somLearning = new SOMLearning(Network.distanceNetwork);
}
else if (Network.loadDistanceNetwork == null)
{
Network.distanceNetwork = new DistanceNetwork(principalComponentAnalysis.Result.GetLength(1), (int)Math.Pow(sqrt, 2));
somLearning = new SOMLearning(Network.distanceNetwork);
}
else if (Network.loadActivationNetwork != null)
{
Network.distanceNetwork = Network.loadDistanceNetwork;
}
//change double [,] to double[][]
double[][] data = new double[listImages.Count][];
for (int i = 0; i < listImages.Count; i++)
{
data[i] = new double[principalComponentAnalysis.Result.GetLength(1)];
for (int j = 0; j < principalComponentAnalysis.Result.GetLength(1); j++)
{
data[i][j] = principalComponentAnalysis.Result[i, j];
}
}
if (somLearning != null)
{
double maxEpochs = 10000, errorRate = 0.0000001;
for (int i = 0; i < maxEpochs; i++)
{
double error = somLearning.RunEpoch(data);
if (error < errorRate)
{
break;
}
}
}
}
