private void showInfo(NeuronDict aliveNeurons, List <List <int> > outputVectors)
{
List <KeyValuePair <Tuple <int, int>, List <int> > > temp = aliveNeurons.ToList();
temp.Sort((x, y) =>
{
return(-1 * x.Value.Count().CompareTo(y.Value.Count()));
});
Console.WriteLine("Top 3 neuron weights by popularity:");
for (int pind = 0; pind < 3; ++pind)
{
Console.WriteLine(String.Join(" ", neurons_.get(temp[pind].Key).weights_));
int classesCount = outputVectors[pind].Count();
List <double> classes = new List <double>(new double[classesCount]);
foreach (int inputInd in temp[pind].Value)
{
classes = classes.Zip(outputVectors[inputInd], (x, y) => (x + y)).ToList();
}
classes = classes.Select(x => 100.0 * x / (1.0 * temp[pind].Value.Count())).ToList();
Console.WriteLine("Class representation: " + String.Join("% ", classes) + "%\n");
}
}
private void spreadOverPopularNeurons(List <List <double> > inputData,
List <int>[,] labels,
NeuronDict aliveNeurons,
List <List <double> > winnerWeights)
{
for (int x = 0; x < latticeSize_; ++x)
{
for (int y = 0; y < latticeSize_; ++y)
{
List <int> ls = labels[x, y];
int labelsLen = ls.Count();
if (labelsLen > 0 && labelsLen <= 2) //just check "introvert" neurons
{
foreach (int label in ls)
{
List <double> singleObservation = inputData[label];
double[,] distances = Utility.calcProximityMetrics(singleObservation, neurons_);
Tuple <int, int> closestPopularNeuron = Utility.findClosestPopularNeuron(distances,
aliveNeurons,
latticeSize_);
aliveNeurons[closestPopularNeuron].Add(label);
winnerWeights[label] = neurons_.get(closestPopularNeuron).weights_;
}
}
}
}
}
public void run(List <List <double> > inputData, List <List <int> > outputVectors)
{
int inputDataLen = inputData.Count();
List <List <double> > winnerWeights = initWinnerWeights(inputDataLen);
List <int>[,] labels;
Utility.initLabels(out labels, latticeSize_);
double[,] latticeDist = precalcLatticeDist();
int time = 0;
double currError = 1e3;
double prevError = 0.0;
while (Math.Abs(currError - prevError) > trainingError_)
{
Utility.clearLabels(labels, latticeSize_);
for (int inputInd = 0; inputInd < inputData.Count(); ++inputInd)
{
List <double> singleObservation = inputData[inputInd];
double[,] distances = Utility.calcProximityMetrics(singleObservation, neurons_);
Tuple <int, int> neuronWinnerCoord = Utility.findClosestNeuron(distances, latticeSize_);
winnerWeights[inputInd] = neurons_.get(neuronWinnerCoord).weights_;
labels[neuronWinnerCoord.Item1, neuronWinnerCoord.Item2].Add(inputInd);
}
updateWeights(labels, inputData, latticeDist, time);
prevError = currError;
currError = Utility.calculateTrainingError(winnerWeights, inputData);
++time;
}
NeuronDict aliveNeurons = chooseAliveNeurons(labels);
spreadOverPopularNeurons(inputData, labels, aliveNeurons, inputData);
showInfo(aliveNeurons, outputVectors);
//store utilities
//storeLatticeWeights("ba_weights_" + time.ToString() + ".txt");
//currError = Utility.calculateTrainingError(ref winnerWeights, ref inputData);
//Console.WriteLine("Training error AFTER exlusion dead nodes: " + currError);
//Console.WriteLine("Epochs passed: " + time);
}
private NeuronDict chooseAliveNeurons(List <int>[,] labels)
{
NeuronDict aliveNeurons = new NeuronDict();
for (int x = 0; x < latticeSize_; ++x)
{
for (int y = 0; y < latticeSize_; ++y)
{
List <int> ls = labels[x, y];
int labelsLen = ls.Count();
if (labelsLen > 2)
{
aliveNeurons[new Tuple <int, int>(x, y)] = labels[x, y].Select(val => val).ToList();
labels[x, y].Clear();
}
}
}
return(aliveNeurons);
}
public static Tuple <int, int> findClosestPopularNeuron(double[,] distances,
NeuronDict aliveNeurons,
int latticeSize)
{
List <Tuple <double, int, int> > temp = new List <Tuple <double, int, int> >();
for (int rowInd = 0; rowInd < latticeSize; ++rowInd)
{
for (int colInd = 0; colInd < latticeSize; ++colInd)
{
Tuple <int, int> coord = new Tuple <int, int>(rowInd, colInd);
if (aliveNeurons.ContainsKey(coord))
{
temp.Add(new Tuple <double, int, int>(distances[rowInd, colInd], rowInd, colInd));
}
}
}
temp = temp.OrderByDescending(i => i.Item1).ToList();
return(new Tuple <int, int>(temp[0].Item2, temp[0].Item3));
}
public static Tuple<int, int> findClosestPopularNeuron(double[,] distances,
NeuronDict aliveNeurons,
int latticeSize)
{
List<Tuple<double, int, int>> temp = new List<Tuple<double, int, int>>();
for (int rowInd = 0; rowInd < latticeSize; ++rowInd)
{
for (int colInd = 0; colInd < latticeSize; ++colInd)
{
Tuple<int, int> coord = new Tuple<int, int>(rowInd, colInd);
if (aliveNeurons.ContainsKey(coord))
{
temp.Add(new Tuple<double, int, int>(distances[rowInd, colInd], rowInd, colInd));
}
}
}
temp = temp.OrderByDescending(i => i.Item1).ToList();
return new Tuple<int, int>(temp[0].Item2, temp[0].Item3);
}
