/// <summary>
/// Calcul à partir des entrées fournies les sorties prédites par le réseau
/// </summary>
/// <param name="Entrees">Liste contenant les entrées du reseau</param>
/// <returns>Listes des sorties prédites par le réseau</returns>
public List <double> TesterReseau(List <List <double> > Entrees)
{
List <double> Sorties = new List <double>();
for (int Echantillon = 0; Echantillon < Entrees.Count; Echantillon++)
{
// Définition des entrées
for (int i = 0; i < Entrees[0].Count; i++)
{
TableauCouches[0][i].ImposerSortie(Entrees[Echantillon][i]);
}
// Définition du biais
Neurone Biais = TableauCouches[0][Entrees[0].Count];
Biais.ImposerSortie(1);
// Calcul de la sortie de chaque neurone avec le réseau actuel
for (int i = 1; i < TableauCouches.Length; i++)
{
CalculerSortieCouche(i);
}
// Récupération de la valeur du neurone de sortie
Neurone Sortie = TableauCouches[TableauCouches.Length - 1][0];
// Ajout du neurone de sortie à la liste des neurones de sortie
Sorties.Add(Sortie.Sortie);
}
return(Sorties);
}
/// <summary>
/// Calcul des poids synaptiques à adopter de façon à obtenir les valeurs de sortie
/// souhaitées
/// </summary>
/// <param name="Entrees">Vecteur contenant les valeurs des neurones d’entrée</param>
/// <param name="Sorties">Vecteur contenant les valeurs des neurones de sortie</param>
/// <param name="Alpha">Coefficient d’apprentissage</param>
/// <param name="Interations">Nombre d’itérations pour l’apprentissage</param>
public void Retropropagation(List <List <double> > Entrees, List <double> Sorties, double Alpha, int Interations)
{
double Sortie;
Neurone Neurone, NeuroneSuivant;
int NbCouches = TableauCouches.Length;
// Pour chaque apprentissage
for (int Iteration = 0; Iteration < Interations; Iteration++)
{
// Pour chaque échantillon
for (int Echantillon = 0; Echantillon < Entrees.Count; Echantillon++)
{
// Définition des entrées
for (int i = 0; i < Entrees[0].Count; i++)
{
TableauCouches[0][i].ImposerSortie(Entrees[Echantillon][i]);
}
// Ajout du biais
Neurone = TableauCouches[0][Entrees[0].Count];
Neurone.ImposerSortie(1);
// Définition de la sortie souhaitée
Sortie = Sorties[Echantillon];
// Calcul de la sortie véritable de chaque neurone, couche par couche
for (int Couche = 1; Couche < NbCouches; Couche++)
{
CalculerSortieCouche(Couche);
}
// Calcul du gradient pour le(s) neurone(s) de la couche de sortie
for (int i = 0; i < TableauCouches[NbCouches - 1].Count; i++)
{
Neurone = TableauCouches[NbCouches - 1][i];
Neurone.ActualiserDelta(Neurone.gprime(Neurone.Somme) * (Sortie - Neurone.Sortie));
}
// Calcul du gradient pour les neurones des couches cachées
for (int Couche = NbCouches - 2; Couche > -1; Couche--)
{
// Pour chaque neurone de cette couche, on met à jour les poids
for (int NumeroNeurone = 0; NumeroNeurone < TableauCouches[Couche].Count; NumeroNeurone++)
{
Neurone = TableauCouches[Couche][NumeroNeurone];
Neurone.ActualiserDelta(Neurone.gprime(Neurone.Somme) * RecuperDelta(Neurone));
// Mise à jour des poids entre les neurones de la couche et ceux de la couche suivante
for (int i = 0; i < TableauCouches[Couche + 1].Count; i++)
{
NeuroneSuivant = TableauCouches[Couche + 1][i];
MatricePoids[Neurone.Numero, NeuroneSuivant.Numero] +=
Alpha * Neurone.Sortie * NeuroneSuivant.Delta;
}
}
}
}
}
}