public static void ShowNetwork(FFANN ffann)
{
for (int i = 0; i < ffann.NumLayers; i++)
{
ffann.layer[i].showLayerAction();
}
}
//Calcola la variazione dei pesi sinaptici da applicare a ciascun collegamento sinaptico.
//Per ogni neurone interno sommo gli errori delle SUE SINAPSI e basta.
private double Delta(FFANN ffann, int j, int k, int q)
{
double _delta = 0;
if (j == ffann.NumLayers - 2)
{
_delta = ffann.layer[j + 1].act.Derr1(desired_output[q], ffann.layer[j + 1].perceptron[q].getAction());
}
else
{
if (dterr[j + 1][q] != 0)
{
_delta = dterr[j + 1][q] * ffann.layer[j + 1].act.Dcompute(ffann.layer[j + 1].perceptron[q].getAction());
}
else
{
_delta = (dterr[j + 1][q] + 1) * ffann.layer[j + 1].act.Dcompute(ffann.layer[j + 1].perceptron[q].getAction());
}
}
dterr[j][k] += _delta * ffann.layer[j].perceptron[k].getSynapsys(q);
if (delta[j][k][q] * _delta <= 0) //se il segno della derivata rimane uguale per due correzioni di fila, aumentiamo la velocità nel verso opposto.
{
return(c1 * _delta * ffann.layer[j].perceptron[k].getAction());
}
else
{
return(c2 * _delta * ffann.layer[j].perceptron[k].getAction() + m * delta[j][k][q] /*Momentum*/);
}
}
public Particle_swarm_optimization(FFANN ffann, double[][] stdDataset)
{
Random Rand = new Random();
Cohesion = Rand.NextDouble();
Separation = Rand.NextDouble();
}
public Layer(short n, FFANN parent, Random rand, Activation value)
{
N = n;
act = value;
ffann = parent;
perceptron = new Perceptron[ffann.NumPercept[N]];
for (int i = 0; i < ffann.NumPercept[N]; i++)
{
perceptron[i] = new Perceptron(i, this, rand);
}
}
public static void ShowWeights(FFANN ffann)
{
for (int i = 0; i < ffann.NumLayers; i++)
{
for (int j = 0; j < ffann.NumPercept[i]; j++)
{
Console.Write("\n");
for (int k = 0; k < ffann.layer[i].perceptron[j].NumSynapses; k++)
{
Console.WriteLine("Layer " + i + " percettrone " + j + " sinapsi " + k + ": " + ffann.layer[i].perceptron[j].getSynapsys(k));
}
}
}
}
//Costruttore, si occupa dell'allenamento vero e proprio.
public RPropPlus(FFANN ffann, double[][] stdDataset)
{
int epochs = 0;
desired_output = new double[ffann.NumPercept[ffann.NumLayers - 1]];
//inizializzazione di delta[][][].
delta = new double[ffann.NumLayers - 1][][]; //Matrice delta che conterrà le correzione dei pesi da applicare alla fine della propagazione.
for (int i = 0; i < ffann.NumLayers - 1; i++)
{
delta[i] = new double[ffann.NumPercept[i]][];
}
for (int j = 0; j < delta.Length; j++)
{
for (int i = 0; i < delta[j].Length; i++) //Calcolo il numero totale di sinapsi nella rete.
{
delta[j][i] = new double[ffann.NumPercept[j + 1]];
}
}
//Fine inizializzazione delta[][][].
//Inizializzo ed azzero la matrice dterr.
dterr = new double[ffann.NumLayers - 1][];
for (int i = 0; i < ffann.NumLayers - 1; i++)
{
dterr[i] = new double[ffann.NumPercept[i]];
for (int z = 0; z < ffann.NumPercept[i]; z++)
{
dterr[i][z] = 0;
}
}
//Fine azzeramento.
do //Scorro le epoche in cui la rete si allenerà.
{
Error = 0;
for (int i = 0; i < stdDataset.Length; i++) //Scorro tutti i samples nel dataset.
{
ffann.Predict(stdDataset[i]); //Calcolo le uscite della rete dato il sample i.
//Copio i valori desiderati in un vettore comodo e calcolo l'Errore Quadratico Medio.
for (int j = 0; j < ffann.NumPercept[ffann.NumLayers - 1]; j++)
{
desired_output[j] = stdDataset[i][ffann.NumPercept[0] + j];
Error += ffann.layer[ffann.NumLayers - 1].act.Err(desired_output[j], ffann.layer[ffann.NumLayers - 1].perceptron[j].getAction());
}
//End
//Calcolo i delta dei pesi sinaptici.
for (int j = ffann.NumLayers - 2; j >= 0; j--) //Scorro la rete dal penultimo layer al primo, per avere accesso diretto ai pesi sinaptici da correggere.
{
for (int k = 0; k < ffann.NumPercept[j]; k++) // Scorro i percettroni dello strato j.
{
for (int q = 0; q < ffann.NumPercept[j + 1]; q++) // Scorro le sinapsi.
{
delta[j][k][q] = Delta(ffann, j, k, q);
}
}
}
//Setto i nuovi pesi applicando i delta dei pesi sinaptici.
for (int j = 0; j < ffann.NumLayers - 1; j++)
{
for (int k = 0; k < ffann.NumPercept[j]; k++)
{
for (int q = 0; q < ffann.NumPercept[j + 1]; q++)
{
ffann.layer[j].perceptron[k].setSynapsys(ffann.layer[j].perceptron[k].getSynapsys(q) - delta[j][k][q], q);
}
}
}
//è necessario azzerare dterr per ogni sample analizzato.
for (int j = 0; j < dterr.Length; j++)
{
for (int z = 0; z < dterr[j].Length; z++)
{
dterr[j][z] = 0;
}
}
//Fine azzeramento.
}
//Stampa l'errore quadratico medio se if è true.
epochs++;
if (epochs % 100 == 0)
{
Console.WriteLine("\nErrore Quadratico Medio: " + Error + "\n");
}
if (Error <= 11)
{
Console.Write("\nEpoche: " + epochs + "\n" + "\n Errore Quadratico Medio: " + Error + "\n");
}
} while ((epochs != 400) && (Error > 11));
}
public void Shape(FFANN ffann)
{
}
public Equilizer(FFANN ffann)
{
}
private void Mutate(FFANN ffann)
{
}
private void Cross(FFANN ffann)
{
}
public Genetic(FFANN ffann, double[][] stdDataset)
{
Random Rand = new Random();
Fitness = Rand.NextDouble();
}
static void Main(string[] args)
{
string[][] Dataset;
double[][] stdDataset;
double[] data;
string[] colTypes;
Console.WriteLine("Ciao e benvenuto nella Learning Part di Jarvis 0.1.");
Console.ReadKey();
//Segmento di prova per la standardizzazione dei dati in ingresso (Solo numerici e categorici, no audio/immagini)
string buffer;
string datasetPath = "C:/Users/Shea/Documents/Visual Studio 2015/Projects/ConsoleApplication1/Dataset.txt";
Console.WriteLine("Ora leggo il Dataset " + datasetPath + ":");
Console.ReadKey();
int numSamples;
int i = 0;
StreamReader reader = new StreamReader(datasetPath);
colTypes = reader.ReadLine().Split(' ');
numSamples = File.ReadAllLines(datasetPath).Length - 1;
Dataset = new string[numSamples][];
data = new double[colTypes.Length];
while ((buffer = reader.ReadLine()) != null)
{
Dataset[i++] = buffer.Split(',');
}
;
reader.Close();
/*Console.WriteLine("\nDataset letto: \n");
* for (i = 0; i < Dataset.Length; i++)
* {
* Console.Write("\n");
* for (int j = 0; j < Dataset[0].Length; j++)
* Console.WriteLine(Dataset[i][j]);
* }
* Console.ReadKey();*/
Console.WriteLine("\nSuccesso. Standardizzo il dataset...");
Console.ReadKey();
Standardizer std = new Standardizer(Dataset, colTypes);
stdDataset = std.StandardizeAll(Dataset);
/*Console.WriteLine("Dati standardizzati:\n");
* helper.ShowMatrix(stdDataset, numSamples, stdDataset[0].Length);
* Console.ReadKey();*/
//Fine segmento di Prova
Console.WriteLine("Successo. Inizializzo la Rete Neurale...");
Console.ReadKey();
FFANN ffann = new FFANN(colTypes.Length, stdDataset[0].Length - Dataset[0].Length + 1); //Setting Network parameters & Creating it.
Console.WriteLine("\nStruttura della Rete Neurale: \n");
Helpers.ShowWeights(ffann);
Console.ReadKey();
Console.WriteLine("Successo, ora avvìo l'allenamento con Backpropagation...");
Console.ReadKey();
RPropPlus trainer = new RPropPlus(ffann, stdDataset);
Console.WriteLine("\nNuova struttura della Rete Neurale: \n");
Helpers.ShowWeights(ffann);
Console.ReadKey();
Console.WriteLine("Successo, inserisci dati di prova per effetuare una predizione: ");
string[] buff;
do
{
do
{
buffer = Console.ReadLine();
buff = buffer.Split(',');
} while (buff.Length != colTypes.Length - 1);
data = std.GetStandardRow(buff);
ffann.PredictShow(data);
Console.ReadKey();
Console.WriteLine("\nProvare ancora? 'y' = yes, others = no: ");
} while (Console.ReadLine().Equals("y"));
}