public void TesterReseau(SauvegardeExcel s, int indice)
{
// On récupère les 200 dernières données pour tester.
Donnees = new Donnees(MonnaieBTC.XRP, "BTC", "5m", "200");
// Les données
double[] output = new double[1];
List <Double> listeInput = Donnees.Neurone.RecupererToutesDonnees(0, NbPasse);
double[] input = listeInput.ToArray();
// Erreur sur le réseau.
double erreur = Reseau.CalculateError(TrainingSet);
Reseau.Compute(input, output);
double prevision = output[0];
// Erreur sur le réseau optimal entrainement.
double erreurEntrainement = this.ReseauOptimalEntrainement.CalculateError(TrainingSet);
ReseauOptimalEntrainement.Compute(input, output);
double previsionEntrainement = output[0];
// Erreur sur le réseau optimal validation.
double erreurValidation = this.ReseauOptimalValidation.CalculateError(ValidationSet);
ReseauOptimalValidation.Compute(input, output);
double previsionValidation = output[0];
s.EcritureDonnees(erreur, prevision, erreurEntrainement, previsionEntrainement, erreurValidation, previsionValidation, indice);
}
/// <summary>
/// Méthode qui va ping la machine.
/// </summary>
/// <param name="machine"></param>
/// <returns></returns>
private async Task PingMachine(MachineToTestDisplay machine)
{
var oldValue = machine.StatusMachine;
machine.StatusMachine = Status.InTesting;
ReponsePing resultPing = await Reseau.PingHostAsync(machine.NomMachine);
if (resultPing.IsPingable)
{
machine.StatusMachine = Status.Connected;
if (oldValue == Status.NotConnected)
{
Notify.ShowNotification("PING", machine.NomMachine + " en ligne", System.Windows.Forms.ToolTipIcon.Info);
}
// Résoudre le DNS.
var adresses = await Reseau.DnsTestAsync(machine.NomMachine);
int nbreIp = adresses.Count();
switch (nbreIp)
{
// Si 0, pas de DNS configuré.
case 0:
machine.IpAdresse = "Aucun adresse IP trouvé";
machine.DnsStatus = StatusDns.NoDns;
break;
case 1:
machine.IpAdresse = adresses.First();
machine.DnsStatus = StatusDns.GoodDns;
break;
// DNS qui contient plusieurs IP pour la même adresse.
default:
machine.IpAdresse = string.Join(" - ", adresses);
machine.DnsStatus = StatusDns.ErrorDns;
break;
}
}
else
{
if (oldValue == Status.Connected)
{
Notify.ShowNotification("PING", machine.NomMachine + " déconnecté", System.Windows.Forms.ToolTipIcon.Error);
}
machine.StatusMachine = Status.NotConnected;
}
machine.Temps = resultPing.TimePing;
}
static void Main(string[] args)
{
Thread.Sleep(1000);
Reseau rezo = new Reseau(Etat.SERVER);
rezo.DataReceived += Rezo_DataReceived;
rezo.FinRechercheServer += Rezo_FinRechercheServer;
while (true)
{
rezo.SendData(Console.ReadLine());
}
}
public Game()
{
InitializeComponent();
Labyrinthe = new Maze(51);
Affichage = new LabyPanel(Labyrinthe);
Affichage.Location = new Point(0, 0);
Controls.Add(Affichage);
Liaison = new Reseau();
Gestion = new Gestion(Labyrinthe, Affichage, Liaison);
Gestion.Start();
}
static void Main(string[] args)
{
Console.WriteLine("SERVER !");
Thread.Sleep(1000);
Reseau r = new Reseau();
r.Initialize();
r.CreationServer();
while (true)
{
r.SendData(Console.ReadLine());
}
//r.stopLoop(Console.ReadLine());
Console.ReadLine();
}
static void Main(string[] args)
{
rezo = new Reseau(Etat.CLIENT);
rezo.DataReceived += Rezo_DataReceived;
rezo.FinRechercheServer += Rezo_FinRechercheServer;
Labyrinthe.PositionsJoueurs pos = new Labyrinthe.PositionsJoueurs();
Console.ReadLine();
//rezo.SendData("ping");
rezo.SendData(pos);
/*zo.SendData(DateTime.Now);
* rezo.SendData(new int[] { 0, 1, 2, 3, 4, 5, 6 });*/
while (true)
{
rezo.SendData(Console.ReadLine());
}
}
static void Main(string[] args)
{
Console.WriteLine("CLIENT !");
rezo = new Reseau();
rezo.Initialize();
rezo.DataReceived += Rezo_DataReceived;
while (true)
{
rezo.SendData(Console.ReadLine());
if (rezo.Clients != null)
{
foreach (var item in rezo.Clients)
{
Console.WriteLine(item);
}
}
}
Console.ReadLine();
}
/// <summary>
/// Entraine le réseau.
/// </summary>
public void EntrainementReseau()
{
// Entrainement du réseau.
double erreurEntrainement = 0;
double erreurValidation = 0;
int epoch = 1;
do
{
train.Iteration();
// Entrainement du réseau.
erreurEntrainement = Reseau.CalculateError(TrainingSet);
ListeErreurEntrainement.Add(erreurEntrainement);
if (erreurEntrainement < ErreurOptimaleEntrainement)
{
ErreurOptimaleEntrainement = erreurEntrainement;
ReseauOptimalEntrainement = (BasicNetwork)Reseau.Clone();
}
// Validation du réseau.
erreurValidation = Reseau.CalculateError(ValidationSet);
ListeErreurValidation.Add(erreurValidation);
if (erreurValidation < ErreurOptimaleValidation)
{
ErreurOptimaleValidation = erreurValidation;
ReseauOptimalValidation = (BasicNetwork)Reseau.Clone();
}
epoch++;
} while (epoch < NbEpochMax);// && erreurEntrainement != 0 && erreurValidation != 0);
train.FinishTraining();
}
public Udp(int port)
{
OpenPort(port);
Token = Reseau.CreateToken();
}
/// <summary>
/// Création, apprentissage et test du réseau en fonction des souhaits de l’utilisateur
/// (nombre de couches du réseau et nombre de neurones par couches cachées, nombre d’itérations
/// dans l’apprentissage et coefficient d’apprentissage) pour les données fournies dans
/// « dataetclassif.txt »
/// </summary>
private void Reseau_Button_Click(object sender, EventArgs e)
{
// Initialisation des variables
int NbCouches = 0;
int NbNeurones = 0;
int NbIterations = 0;
double CoefApprentissage = 0;
try
{
// Récupération des données inscrites dans les champs par l’utilisateur
NbCouches = Convert.ToInt32(NbCouches_TextBox.Text);
if (NbCouches <= 1)
{
throw new Exception("Le nombre de couches doit être au minimum de 2.");
}
NbNeurones = Convert.ToInt32(NbNeurones_TextBox.Text);
if (NbNeurones <= 0)
{
throw new Exception("Le nombre de neurones par couches cachées doit être au minimum de 1.");
}
NbIterations = Convert.ToInt32(NbIterations_TextBox.Text);
if (NbIterations <= 0)
{
throw new Exception("Le nombre d’itérations doit être au minimum de 1.");
}
CoefApprentissage = Convert.ToDouble(CoefApprentissage_TextBox.Text);
if (CoefApprentissage <= 0 && CoefApprentissage >= 1)
{
throw new Exception("Le coefficient d’apprentissage doit être compris entre 0 et 1 exclus.");
}
// Création du réseau (3 entrées car un couple de données + le biais)
Reseau = new Reseau(3, NbCouches, NbNeurones);
// Récupération des valeurs d’entrées
List <List <double> > Entrees = this.RecupererDonnees();
// Récupération des sorties désirées
List <double> Sorties = new List <double>();
for (int i = 0; i < 3000; i++)
{
if (i < 1500)
{
Sorties.Add(0.1);
}
else
{
Sorties.Add(0.9);
}
}
// Mélange des listes
List <List <double> > EntreesM = new List <List <double> >();
List <double> SortiesM = new List <double>();
for (int i = 0; i < 1500; i++)
{
EntreesM.Add(new List <double> {
Entrees[i][0] / 800.0, Entrees[i][1] / 800.0
});
SortiesM.Add(Sorties[i]);
EntreesM.Add(new List <double> {
Entrees[i + 1500][0] / 800.0, Entrees[i + 1500][1] / 800.0
});
SortiesM.Add(Sorties[1500 + i]);
}
// Apprentissage supervisé
Secondes = 0;
Chrono_Timer.Start();
Reseau.Retropropagation(EntreesM, SortiesM, CoefApprentissage, NbIterations);
Chrono_Timer.Stop();
// Affichage de l’image de résultat
Tests();
// Affichage des valeurs du fichier
for (int i = 0; i < 3000; i++)
{
Entrees[i][0] = Math.Floor(Entrees[i][0]);
Entrees[i][1] = Math.Floor(Entrees[i][1]);
if (i < 1500)
{
Supervise_Form.Image.SetPixel((int)Entrees[i][0], (int)Entrees[i][1], Color.Black);
}
else
{
Supervise_Form.Image.SetPixel((int)Entrees[i][0], (int)Entrees[i][1], Color.White);
}
}
// Calcul du pourcentage de bonne et mauvaise classification et calcul de l’erreur résiduelle
List <double> SortiesCalculees = Reseau.TesterReseau(EntreesM);
double ErreurResiduelle = 0;
int BonneClassification = 0;
int MauvaiseClassification = 0;
for (int i = 0; i < SortiesCalculees.Count; i++)
{
if (i % 2 == 0)
{
if (SortiesCalculees[i] < 0.5)
{
BonneClassification++;
}
else
{
MauvaiseClassification++;
}
ErreurResiduelle += Math.Abs(SortiesCalculees[i] - 0.1);
}
else
{
if (SortiesCalculees[i] > 0.5)
{
BonneClassification++;
}
else
{
MauvaiseClassification++;
}
ErreurResiduelle += Math.Abs(SortiesCalculees[i] - 0.9);
}
}
// Rafraîchissement de l’image et affiche des performances dans une boîte de dialogue
Resultat_PictureBox.Refresh();
string Message = "Pourcentage de bonne classification : " + Math.Round(BonneClassification / 3000.0, 4) * 100 +
"\nPourcentage de mauvaise classification : " + Math.Round(MauvaiseClassification / 3000.0, 4) * 100 +
"\nErreur résiduelle : " + Math.Round(ErreurResiduelle / 3000.0, 2);
MessageBox.Show(Message, "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception Ex)
{
MessageBox.Show(Ex.Message, "Erreur", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
