private KohonenNeurone RechercherGagnant(double[] cible)
{
double distanceMin = double.MaxValue;
KohonenNeurone gagnant = null;
for (int x = 0; x < X; x++)
{
for (int y = 0; y < Y; y++)
{
KohonenNeurone neurone = Grille[x, y] as KohonenNeurone;
// pour chaque neurone on calcule sa distance euclidienne avec l'entrée
double distance = Helper.Distance(cible, neurone.Poids);
// est-ce le gagnant?
if (distance < distanceMin)
{
distanceMin = distance;
gagnant = neurone;
}
}
}
gagnant.NbGagnant++;
return(gagnant);
}
private double Distance(KohonenNeurone v1, KohonenNeurone v2)
{
///Distance euclidienne
double distance = Math.Sqrt((v1.X - v2.X) * (v1.X - v2.X) + (v1.Y - v2.Y) * (v1.Y - v2.Y));
return(distance);
}
/// <summary>
/// Renvoie le voisinage du gagnant
/// </summary>
/// <param name="gagnant"></param>
/// <param name="totalIteration"></param>
/// <param name="iterationCourante"></param>
/// <returns></returns>
private List <KohonenNeurone> Voisinage(KohonenNeurone gagnant, int totalIteration, int iterationCourante)
{
// on commence par calculer le rayon
double rayon = FonctionsAttenuation.Sigma(RayonCarte, totalIteration, iterationCourante);
// on recherche les neurones présents dans le rayon
// leurs poids seront ajustés
List <KohonenNeurone> voisinage = new List <KohonenNeurone>();
for (int x = 0; x < Grille.GetLength(0); x++)
{
for (int y = 0; y < Grille.GetLength(1); y++)
{
KohonenNeurone neurone = Grille[x, y];
neurone.Distance = Distance(neurone, gagnant);
if (neurone.Distance <= rayon)
{
voisinage.Add(neurone);
}
}
}
Debug.WriteLine("Voisinage: " + voisinage.Count.ToString());
return(voisinage);
}
public void CalculerCouleurDepuisPoids(KohonenNeurone neurone)
{
// on suppose que l'entrée a une taille de 3, sinon faut trouver un autre algo
// & 0xff pour le cas où le poids devient plus grand que 1
int r = (int)(255 * neurone.Poids[0]);
int g = (int)(255 * neurone.Poids[1]);
int b = (int)(255 * neurone.Poids[2]);
neurone.Couleur = Color.FromArgb(r & 0xff, g & 0xff, b & 0xff);
}
/// <summary>
///
/// </summary>
/// <param name="cible">Jeux d'essai</param>
/// <param name="iterationCourante">Itération courante</param>
/// <param name="iterations">Nombre d'itération prévues pour la phase d'entrainement</param>
public void Entrainer(double[] cible, int iterations, int iterationCourante)
{
// recherche du meilleur neurone
KohonenNeurone gagnant = RechercherGagnant(cible);
// récupère le voisinage du gagnant
List <KohonenNeurone> voisinage = Voisinage(gagnant, iterations, iterationCourante);
if (voisinage.Count == 0)
{
return;
}
// ajuste les poids
AjusterPoids(voisinage, cible, iterations, iterationCourante);
Pas = PasInitial * Math.Exp(-(iterationCourante / iterations));
}
private void AfficherChemin(KohonenNeurone[] line)
{
Graphics g = Schema.CreateGraphics();
Point[] chemin = new Point[line.Length];
for (int i = 0; i < line.Length; i++)
{
KohonenNeurone neurone = line[i];
chemin[i] = new Point((int)neurone.Poids[0], (int)neurone.Poids[1]);
}
Pen pen = new Pen(Color.Red, 2);
g.DrawLines(pen, chemin);
Brush brush = new SolidBrush(Color.DarkBlue);
for (int i = 0; i < chemin.Length; i++)
{
g.FillEllipse(brush, chemin[i].X, chemin[i].Y, 8, 8);
}
}
public void CalculerCouleurDepuisPoids(KohonenNeurone neurone, double[][] couleurs)
{
CalculerCouleurDepuisPoids(neurone);
double plusProche = double.MaxValue;
double[] meilleureCouleur = null;
for (int i = 0; i < couleurs.Length; i++)
{
double distance = Helper.Distance(couleurs[i], neurone.Poids);
if (distance < plusProche)
{
plusProche = distance;
meilleureCouleur = couleurs[i];
}
}
neurone.Couleur = Color.FromArgb((int)meilleureCouleur[0], (int)meilleureCouleur[1], (int)meilleureCouleur[2]);
}
private void Initialiser(int nbEntrees, int x, int y, Color[] couleurs)
{
Grille = new KohonenNeurone[x, y];
Random rnd = new Random();
for (int cx = 0; cx < x; cx++)
{
for (int cy = 0; cy < y; cy++)
{
KohonenNeurone neurone = new KohonenNeurone(nbEntrees);
neurone.X = cx;
neurone.Y = cy;
if (couleurs.Length != 0)
{
int position = rnd.Next(couleurs.Length);
Color couleur = couleurs[position];
neurone.Couleur = couleur;
neurone.Poids[0] = Helper.NormaliserCouleur(neurone.Couleur.R);
neurone.Poids[1] = Helper.NormaliserCouleur(neurone.Couleur.G);
neurone.Poids[2] = Helper.NormaliserCouleur(neurone.Couleur.B);
}
else
{
neurone.Poids[0] = Helper.NormaliserCouleur(rnd.Next(255) / 255);
neurone.Poids[1] = Helper.NormaliserCouleur(rnd.Next(255) / 255);
neurone.Poids[2] = Helper.NormaliserCouleur(rnd.Next(255) / 255);
CalculerCouleurDepuisPoids(neurone);
}
Grille[cx, cy] = neurone;
}
}
// rayon du réseau
RayonCarte = 0.5 * Math.Max(x, y);
}
/// <summary>
/// Renvoie le voisinage du gagnant
/// </summary>
/// <param name="gagnant"></param>
/// <param name="totalIteration"></param>
/// <param name="iterationCourante"></param>
/// <returns></returns>
private List<KohonenNeurone> Voisinage(KohonenNeurone gagnant, int totalIteration, int iterationCourante)
{
// on commence par calculer le rayon
double rayon = FonctionsAttenuation.Sigma(RayonCarte, totalIteration, iterationCourante);
// on recherche les neurones présents dans le rayon
// leurs poids seront ajustés
List<KohonenNeurone> voisinage = new List<KohonenNeurone>();
for (int x = 0; x < Grille.GetLength(0); x++)
{
for (int y = 0; y < Grille.GetLength(1); y++)
{
KohonenNeurone neurone = Grille[x, y];
neurone.Distance = Distance(neurone, gagnant);
if (neurone.Distance <= rayon)
{
voisinage.Add(neurone);
}
}
}
Debug.WriteLine("Voisinage: " + voisinage.Count.ToString());
return voisinage;
}
private void Initialiser(int nbEntrees, int x, int y, Color[] couleurs)
{
Grille = new KohonenNeurone[x, y];
Random rnd = new Random();
for (int cx = 0; cx < x; cx++)
{
for (int cy = 0; cy < y; cy++)
{
KohonenNeurone neurone = new KohonenNeurone(nbEntrees);
neurone.X = cx;
neurone.Y = cy;
if (couleurs.Length != 0)
{
int position = rnd.Next(couleurs.Length);
Color couleur = couleurs[position];
neurone.Couleur = couleur;
neurone.Poids[0] = Helper.NormaliserCouleur(neurone.Couleur.R);
neurone.Poids[1] = Helper.NormaliserCouleur(neurone.Couleur.G);
neurone.Poids[2] = Helper.NormaliserCouleur(neurone.Couleur.B);
}
else
{
neurone.Poids[0] = Helper.NormaliserCouleur(rnd.Next(255) / 255);
neurone.Poids[1] = Helper.NormaliserCouleur(rnd.Next(255) / 255);
neurone.Poids[2] = Helper.NormaliserCouleur(rnd.Next(255) / 255);
CalculerCouleurDepuisPoids(neurone);
}
Grille[cx, cy] = neurone;
}
}
// rayon du réseau
RayonCarte = 0.5 * Math.Max(x, y);
}
private double Distance(KohonenNeurone v1, KohonenNeurone v2)
{
///Distance euclidienne
double distance = Math.Sqrt((v1.X - v2.X) * (v1.X - v2.X) + (v1.Y - v2.Y) * (v1.Y - v2.Y));
return distance;
}
public void CalculerCouleurDepuisPoids(KohonenNeurone neurone, double[][] couleurs)
{
CalculerCouleurDepuisPoids(neurone);
double plusProche = double.MaxValue;
double[] meilleureCouleur = null;
for (int i = 0; i < couleurs.Length; i++)
{
double distance = Helper.Distance(couleurs[i], neurone.Poids);
if (distance < plusProche)
{
plusProche = distance;
meilleureCouleur = couleurs[i];
}
}
neurone.Couleur = Color.FromArgb((int)meilleureCouleur[0], (int)meilleureCouleur[1], (int)meilleureCouleur[2]);
}
public void CalculerCouleurDepuisPoids(KohonenNeurone neurone)
{
// on suppose que l'entrée a une taille de 3, sinon faut trouver un autre algo
// & 0xff pour le cas où le poids devient plus grand que 1
int r = (int)(255 * neurone.Poids[0]);
int g = (int)(255 * neurone.Poids[1]);
int b = (int)(255 * neurone.Poids[2]);
neurone.Couleur = Color.FromArgb(r & 0xff, g & 0xff, b & 0xff);
}
