AccueilCodesTutorielsForumsEmploiLivresGuide achatConnexion

  • C / C++ / C++.NET CodeS-SourceS
  • RSS CodeS-SourceS
  • CodyxBot, le Bot GTalk & MSN qu'il vous faut !
  • Générez des revenus avec vos codes, scripts et tutoriaux
  • Aide à la navigation du site
begin process at 2009 07 05 03:04:58
Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

BIEN EXPLIQUE: EXEMPLE DE RESEAU DE NEURONE


Information sur la source

Catégorie :Maths & Algorithmes Classé sous : reseau, neurone, backpropagation, intelligence, artificielle Niveau : Débutant Date de création : 22/04/2007 Date de mise à jour : 23/04/2007 21:59:57 Vu / téléchargé: 7 812 / 915
Auteur : acx01b Site perso
Ecrire un message privé
Note :
9 / 10 - par 1 personne
9,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Commentaire sur cette source (5)
Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale
il s'agit d'un réseau de neurone qui ne fait que approximer
xor
exponentielle
carré
produit
somme

les explications sur l'algortihme de base du réseau de neurone:
http://www.hacking.free.fr/paris8/Backpropagation.htm

l'intéret est que j'ai écrit 3 pages pour expliquer comment il fonctione, car j'ai dû faire un vrai travail de détective pour réussir à le programmer
notatement je me suis servi d'une source qui marchait bien pour le xor (c'est pas courrant !)

********

pour la détection de lettres :
comme vous pouvez le voir dans le screenshot les résultats sont déja amusants avec seulement 5 exemples "bruités" avec un random

 

Source

  • #include <stdio.h>
  • #include <stdlib.h>
  • #include <math.h>
  • #include <time.h>
  • typedef double mlp_float;
  • typedef struct {
  • mlp_float *poids_synaptique;
  • mlp_float *valeur_neurone;
  • mlp_float *valeur_erreur_neurone;
  • mlp_float *neurone_entree;
  • mlp_float *neurone_sortie;
  • mlp_float *valeur_erreur_sortie;
  • int *index_couche;
  • int *taille_couche;
  • int *index_synapse;
  • int nombre_couche;
  • int nombre_neurone;
  • int nombre_synapse;
  • int taille_couche_entree;
  • int taille_couche_sortie;
  • } mlp;
  • static mlp_float MAGICAL_WEIGHT_NUMBER = 1.0f;
  • static mlp_float MAGICAL_LEARNING_NUMBER = 0.09f;
  • mlp *create_mlp(int nombre_couche, int *taille_couche) {
  • mlp *reseau = malloc(sizeof * reseau);
  • reseau->nombre_couche = nombre_couche;
  • reseau->taille_couche = malloc(sizeof * reseau->taille_couche * reseau->nombre_couche);
  • reseau->index_couche = malloc(sizeof * reseau->index_couche * reseau->nombre_couche);
  • int i;
  • reseau->nombre_neurone = 0;
  • for (i = 0; i < nombre_couche; i++) {
  • reseau->taille_couche[i] = taille_couche[i];
  • reseau->index_couche[i] = reseau->nombre_neurone;
  • reseau->nombre_neurone += taille_couche[i];
  • }
  • reseau->valeur_neurone = malloc(sizeof * reseau->valeur_neurone * reseau->nombre_neurone);
  • reseau->valeur_erreur_neurone = malloc(sizeof * reseau->valeur_erreur_neurone * reseau->nombre_neurone);
  • reseau->taille_couche_entree = taille_couche[0];
  • reseau->taille_couche_sortie = taille_couche[nombre_couche-1];
  • reseau->neurone_entree = reseau->valeur_neurone;
  • reseau->neurone_sortie = &reseau->valeur_neurone[reseau->index_couche[nombre_couche-1]];
  • reseau->valeur_erreur_sortie = &reseau->valeur_erreur_neurone[reseau->index_couche[nombre_couche-1]];
  • reseau->index_synapse = malloc(sizeof * reseau->index_synapse * (reseau->nombre_couche-1));
  • reseau->nombre_synapse = 0;
  • for (i = 0; i < nombre_couche - 1; i++) {
  • reseau->index_synapse[i] = reseau->nombre_synapse;
  • reseau->nombre_synapse += (reseau->taille_couche[i]+1) * reseau->taille_couche[i+1];
  • }
  • reseau->poids_synaptique = malloc(sizeof * reseau->poids_synaptique * reseau->nombre_synapse);
  • for (i = 0; i < reseau->nombre_synapse; i++) {
  • reseau->poids_synaptique[i] = MAGICAL_WEIGHT_NUMBER * (mlp_float)rand() / RAND_MAX - MAGICAL_WEIGHT_NUMBER/2;
  • }
  • return reseau;
  • }
  • void free_mlp (mlp *reseau) {
  • free(reseau->taille_couche);
  • free(reseau->index_couche);
  • free(reseau->valeur_neurone);
  • free(reseau->valeur_erreur_neurone);
  • free(reseau->index_synapse);
  • free(reseau->poids_synaptique);
  • free(reseau);
  • }
  • void set_mlp (mlp * reseau, mlp_float *vecteur) {
  • if (vecteur != NULL) {
  • int i;
  • for (i = 0; i < reseau->taille_couche_entree; i++) {
  • reseau->neurone_entree[i] = vecteur[i];
  • }
  • }
  • int i;
  • int index_synapse;
  • index_synapse = 0;
  • for (i = 1; i < reseau->nombre_couche; i++) {
  • int j;
  • for (j = reseau->index_couche[i]; j < reseau->index_couche[i] + reseau->taille_couche[i]; j++) {
  • mlp_float somme_ponderee = 0.0;
  • int k;
  • for (k = reseau->index_couche[i-1]; k < reseau->index_couche[i-1] + reseau->taille_couche[i-1]; k++) {
  • somme_ponderee += reseau->valeur_neurone[k] * reseau->poids_synaptique[index_synapse];
  • index_synapse++;
  • }
  • somme_ponderee += reseau->poids_synaptique[index_synapse];
  • index_synapse++;
  • reseau->valeur_neurone[j] = somme_ponderee;
  • if (i != reseau->nombre_couche - 1) reseau->valeur_neurone[j] = tanh(reseau->valeur_neurone[j]);
  • }
  • }
  • }
  • void get_mlp (mlp *reseau, mlp_float *vecteur) {
  • int i;
  • for (i = 0; i < reseau->taille_couche_sortie; i++) {
  • vecteur[i] = reseau->neurone_sortie[i];
  • }
  • }
  • void learn_mlp (mlp *reseau, mlp_float *desired_out) {
  • int i;
  • mlp_float global_error = 0;
  • int index_synapse = reseau->index_synapse[reseau->nombre_couche-2];
  • for (i = 0; i < reseau->taille_couche_sortie; i++) {
  • reseau->valeur_erreur_sortie[i] = reseau->neurone_sortie[i] - desired_out[i];
  • int j;
  • for (j = reseau->index_couche[reseau->nombre_couche-2]; j < reseau->index_couche[reseau->nombre_couche-2] + reseau->taille_couche[reseau->nombre_couche-2]; j++) {
  • mlp_float weightChange;
  • weightChange = MAGICAL_LEARNING_NUMBER * reseau->valeur_erreur_sortie[i] * reseau->valeur_neurone[j];
  • reseau->poids_synaptique[index_synapse] -= weightChange;
  • if (reseau->poids_synaptique[index_synapse] > 5) reseau->poids_synaptique[index_synapse] = 5;
  • if (reseau->poids_synaptique[index_synapse] < -5) reseau->poids_synaptique[index_synapse] = -5;
  • index_synapse++;
  • }
  • mlp_float weightChange;
  • weightChange = MAGICAL_LEARNING_NUMBER * reseau->valeur_erreur_sortie[i];
  • reseau->poids_synaptique[index_synapse] -= weightChange;
  • if (reseau->poids_synaptique[index_synapse] > 5) reseau->poids_synaptique[index_synapse] = 5;
  • if (reseau->poids_synaptique[index_synapse] < -5) reseau->poids_synaptique[index_synapse] = -5;
  • index_synapse++;
  • }
  • for (i = reseau->nombre_couche - 2; i > 0; i--) {
  • int j;
  • int jj= 0;
  • int index_synapse = reseau->index_synapse[i-1];
  • for (j = reseau->index_couche[i]; j < reseau->index_couche[i] + reseau->taille_couche[i]; j++,jj++) {
  • int k;
  • int index_synapse2 = reseau->index_synapse[i] + jj;
  • reseau->valeur_erreur_neurone[j] = 0;
  • for (k = reseau->index_couche[i+1]; k < reseau->index_couche[i+1] + reseau->taille_couche[i+1]; k++) {
  • reseau->valeur_erreur_neurone[j] += reseau->poids_synaptique[index_synapse2] * reseau->valeur_erreur_neurone[k];
  • index_synapse2+=reseau->taille_couche[i]+1;
  • }
  • for (k = reseau->index_couche[i-1]; k < reseau->index_couche[i-1] + reseau->taille_couche[i-1]; k++) {
  • mlp_float weightChange;
  • weightChange = 1.0 - reseau->valeur_neurone[j] * reseau->valeur_neurone[j];
  • weightChange *= reseau->valeur_erreur_neurone[j] * MAGICAL_LEARNING_NUMBER;
  • weightChange *= reseau->valeur_neurone[k];
  • reseau->poids_synaptique[index_synapse] -= weightChange;
  • index_synapse++;
  • }
  • mlp_float weightChange;
  • weightChange = 1.0 - reseau->valeur_neurone[j] * reseau->valeur_neurone[j];
  • weightChange *= reseau->valeur_erreur_neurone[j] * MAGICAL_LEARNING_NUMBER;
  • reseau->poids_synaptique[index_synapse] -= weightChange;
  • index_synapse++;
  • }
  • }
  • } 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

typedef double mlp_float;

typedef struct {
    mlp_float *poids_synaptique;
    mlp_float *valeur_neurone;
    mlp_float *valeur_erreur_neurone;
    mlp_float *neurone_entree;
    mlp_float *neurone_sortie;
    mlp_float *valeur_erreur_sortie;
    int *index_couche;
    int *taille_couche;
    int *index_synapse;
    int nombre_couche;
    int nombre_neurone;
    int nombre_synapse;
    int taille_couche_entree;
    int taille_couche_sortie;
} mlp;


static mlp_float MAGICAL_WEIGHT_NUMBER = 1.0f;
static mlp_float MAGICAL_LEARNING_NUMBER = 0.09f;

mlp *create_mlp(int nombre_couche, int *taille_couche) {

    mlp *reseau = malloc(sizeof * reseau);

    reseau->nombre_couche = nombre_couche;
    reseau->taille_couche = malloc(sizeof * reseau->taille_couche * reseau->nombre_couche);
    reseau->index_couche = malloc(sizeof * reseau->index_couche * reseau->nombre_couche);

    int i;
    reseau->nombre_neurone = 0;
    for (i = 0; i < nombre_couche; i++) {
        reseau->taille_couche[i] = taille_couche[i];
        reseau->index_couche[i] = reseau->nombre_neurone;
        reseau->nombre_neurone += taille_couche[i];
    }

    reseau->valeur_neurone = malloc(sizeof * reseau->valeur_neurone * reseau->nombre_neurone);
    reseau->valeur_erreur_neurone = malloc(sizeof * reseau->valeur_erreur_neurone * reseau->nombre_neurone);

    reseau->taille_couche_entree = taille_couche[0];
    reseau->taille_couche_sortie = taille_couche[nombre_couche-1];
    reseau->neurone_entree = reseau->valeur_neurone;
    reseau->neurone_sortie = &reseau->valeur_neurone[reseau->index_couche[nombre_couche-1]];
    reseau->valeur_erreur_sortie = &reseau->valeur_erreur_neurone[reseau->index_couche[nombre_couche-1]];

    reseau->index_synapse = malloc(sizeof * reseau->index_synapse * (reseau->nombre_couche-1));
    reseau->nombre_synapse = 0;
    for (i = 0; i < nombre_couche - 1; i++) {
        reseau->index_synapse[i] = reseau->nombre_synapse;
        reseau->nombre_synapse += (reseau->taille_couche[i]+1) * reseau->taille_couche[i+1];
    }

    reseau->poids_synaptique = malloc(sizeof * reseau->poids_synaptique * reseau->nombre_synapse);

    for (i = 0; i < reseau->nombre_synapse; i++) {
        reseau->poids_synaptique[i] = MAGICAL_WEIGHT_NUMBER * (mlp_float)rand() / RAND_MAX - MAGICAL_WEIGHT_NUMBER/2;

    }
    return reseau;
}

void free_mlp (mlp *reseau) {
    free(reseau->taille_couche);
    free(reseau->index_couche);
    free(reseau->valeur_neurone);
    free(reseau->valeur_erreur_neurone);
    free(reseau->index_synapse);
    free(reseau->poids_synaptique);
    free(reseau);
}


void set_mlp (mlp * reseau, mlp_float *vecteur) {
    if (vecteur != NULL) {
        int i;
        for (i = 0; i < reseau->taille_couche_entree; i++) {
            reseau->neurone_entree[i] = vecteur[i];
        }
    }
    int i;
    int index_synapse;
    index_synapse = 0;
    for (i = 1; i < reseau->nombre_couche; i++) {
        int j;
        for (j = reseau->index_couche[i]; j < reseau->index_couche[i] + reseau->taille_couche[i]; j++) {
            mlp_float somme_ponderee = 0.0;
            int k;
            for (k = reseau->index_couche[i-1]; k < reseau->index_couche[i-1] + reseau->taille_couche[i-1]; k++) {
                somme_ponderee += reseau->valeur_neurone[k] * reseau->poids_synaptique[index_synapse];
                index_synapse++;
            }
            somme_ponderee += reseau->poids_synaptique[index_synapse];
            index_synapse++;
            reseau->valeur_neurone[j] = somme_ponderee;
            if (i != reseau->nombre_couche - 1) reseau->valeur_neurone[j] = tanh(reseau->valeur_neurone[j]);
        }
    }
}


void get_mlp (mlp *reseau, mlp_float *vecteur) {
    int i;
    for (i = 0; i < reseau->taille_couche_sortie; i++) {
        vecteur[i] = reseau->neurone_sortie[i];
    }
}

void learn_mlp (mlp *reseau, mlp_float *desired_out) {


    int i;
    mlp_float global_error = 0;
    int index_synapse = reseau->index_synapse[reseau->nombre_couche-2];

    for (i = 0; i < reseau->taille_couche_sortie; i++) {
        reseau->valeur_erreur_sortie[i] = reseau->neurone_sortie[i] - desired_out[i];
        int j;
        for (j = reseau->index_couche[reseau->nombre_couche-2]; j < reseau->index_couche[reseau->nombre_couche-2] + reseau->taille_couche[reseau->nombre_couche-2]; j++) {
            mlp_float weightChange;
            weightChange = MAGICAL_LEARNING_NUMBER * reseau->valeur_erreur_sortie[i] * reseau->valeur_neurone[j];
            reseau->poids_synaptique[index_synapse] -= weightChange;

            if (reseau->poids_synaptique[index_synapse] > 5) reseau->poids_synaptique[index_synapse] = 5;
            if (reseau->poids_synaptique[index_synapse] < -5) reseau->poids_synaptique[index_synapse] = -5;

            index_synapse++;
        }
        mlp_float weightChange;
        weightChange = MAGICAL_LEARNING_NUMBER * reseau->valeur_erreur_sortie[i];
        reseau->poids_synaptique[index_synapse] -= weightChange;

        if (reseau->poids_synaptique[index_synapse] > 5) reseau->poids_synaptique[index_synapse] = 5;
        if (reseau->poids_synaptique[index_synapse] < -5) reseau->poids_synaptique[index_synapse] = -5;

        index_synapse++;
    }


    for (i = reseau->nombre_couche - 2; i > 0; i--) {
        int j;
        int jj= 0;
        int index_synapse = reseau->index_synapse[i-1];
        for (j = reseau->index_couche[i]; j < reseau->index_couche[i] + reseau->taille_couche[i]; j++,jj++) {
            int k;

            int index_synapse2 = reseau->index_synapse[i] + jj;
            reseau->valeur_erreur_neurone[j] = 0;
            for (k = reseau->index_couche[i+1]; k < reseau->index_couche[i+1] + reseau->taille_couche[i+1]; k++) {
                reseau->valeur_erreur_neurone[j] += reseau->poids_synaptique[index_synapse2] * reseau->valeur_erreur_neurone[k];
                index_synapse2+=reseau->taille_couche[i]+1;
            }

            for (k = reseau->index_couche[i-1]; k < reseau->index_couche[i-1] + reseau->taille_couche[i-1]; k++) {

                mlp_float weightChange;

                weightChange = 1.0 - reseau->valeur_neurone[j] * reseau->valeur_neurone[j];
                weightChange *= reseau->valeur_erreur_neurone[j] * MAGICAL_LEARNING_NUMBER;
                weightChange *= reseau->valeur_neurone[k];

                reseau->poids_synaptique[index_synapse] -= weightChange;
                index_synapse++;
            }
            mlp_float weightChange;

            weightChange = 1.0 - reseau->valeur_neurone[j] * reseau->valeur_neurone[j];
            weightChange *= reseau->valeur_erreur_neurone[j] * MAGICAL_LEARNING_NUMBER;
            reseau->poids_synaptique[index_synapse] -= weightChange;
            index_synapse++;
        }
    }
}

Conclusion

les main sont dans le zip


 

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip

Historique

23 avril 2007 16:46:59 :
je sais pas je m'étais trompé de version d'un des fichiers
23 avril 2007 21:48:15 :
juste un fichier avec quelques lettres 5x3 pixels
23 avril 2007 21:59:58 :
passage à 100000 itérations pour détecter les lettres A B C D E majuscules

Commentaires et avis

signaler à un administrateur
Commentaire de Cphil51 le 22/04/2007 21:25:59

Vais me pencher sur la question dans les jours à venir, ca à l'air vraimet interessant.

signaler à un administrateur
Commentaire de zaagane le 23/04/2007 11:01:42

Salut,

J’ai un source  similaire  qui  calcule  XOR en c++ builder 6 est déposé sur :  http://www.cppfrance.com/codes/EXEMPLE-RESEAU-NEURONES-CALCULE-FONCTION-OU-EXCLUSIF-XOR_40589.aspx

concernat votre source acx01b,
quel est le type de votre réseaux? je ponse SNN (réseau de neurones impulsionnel).

signaler à un administrateur
Commentaire de acx01b le 23/04/2007 16:42:51

salut zaagane

c'est tout expliqué http://www.hacking.free.fr/paris8/Backpropagation.htm

toi apparement tu as utilisé plusieurs grosses différences:
- il n'y a pas de seuil dans ton réseau
- tu utilises une architecture différente du perceptron multicouche
- tu utilises la fonction 1/(1+exp(x))
- tu n'utilises pas de sortie en fonction linéaire de ses entrées
(moi je n'utilise ni tanh, ni exp, ni les dérivées pour la dernière couche)

je voudrais bien par contre que tu me dises de combien d'itérations tu as besoin pour un xor aussi précis que ton réseau le permet
moi j'arrive à 0.00000000000001 comme taux d'erreur:
en 1200 à 3200 itérations (sur 1000 essais)
en 1200 à 6000 itérations (sur 10000 essais)

a+

signaler à un administrateur
Commentaire de hwoarang le 24/06/2008 13:24:25 9/10

Merci pour cette source. J'avais envie de me mettre aux reseaux de neurones et j'ai un peu parcourus le site, ca a l'air bien fait. Bon boulot.

signaler à un administrateur
Commentaire de hwoarang le 27/06/2008 09:42:14

Salut,

Un 2e commentaire pour dire que j'ai testé la source et c'est vraiment super bien fait. J'aime bien la généricité de la création du réseau de neurone.

Felicitations !!!

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

Intelligence Artificielle [ par JCpp ] Concours IA (Intelligence Artificielle) [ par ynizon ] Je suis a la recherche de participants pour un ptit jeu sympa qui ressemble aux dames chinoises. Le but etant que chacun developpe sa propre IA, et l' Intelligence Artificielle... [ par kojiro2 ] Coucou tout le monde,J'aurai bien aimé connaitre de bons sites sur l'IA. En effet je ne trouve rien d'exeptionnel sur le net. Ya pas des sites sympas Esce que je peux utiliser le c++ pour programmer l'intelligence artificielle d'un robot? [ par Uims ] tout est dans la question...merciUims intelligence artificielle pour jeu 2d à la mario bros [ par StrikerFred ] bonjour, je fais un jeu 2d mais avec une vue style mario (profil)donc y'aura des ennemis, et j'aimerais qu'ils se dirigent vers le h&#233;ros, cad qu' Projet : Réalisation d'une intelligence artificielle aux échecs. [ par manta7 ] Bonjour &#224; tous, je souhaite r&#233;aliser une IA aux &#233;checs, pour le moment, le projet est assez floue mais si cela vous tente : manta7 arob Projet en Intelligence Artificielle [ par manta7 ] Salut à tous, Développeur en C (et finaliste de Prologin ),  je recherche des personnes qui veulent participer à un projet de programmation sur le thè Intelligence artificielle [ par Alice89 ] Bonjour Nous sommes deux étudiantes en informatique et cherc Ecole d'intelligence artificielle [ par eldiablomortal ] Bonjour voila je suis actuellement en BTS informatique de gestion option developpeur. J'envisage de poursuivre mes etudes. Et je voudrais essayer l'in comment extraire le SSID d'un reseau wifi? [ par sbsiam ] Bonjour tout le monde;j'essay de faire une application simple qui affiche le SSID et la qualit&#233; du signale pou mon reseau WIFI. j'ai trouver une


Nos sponsors

Sondage...

CalendriCode

Juillet 2009
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode

Téléchargements

Logiciels à télécharger sur le même thème :

Comparez les prix Nouvelle version


HTC Touch HD
Entre 25€ et 605€


Visiter le guide achat

Photothèque Nouveau !

Photo alphabet langue des sourdsPhoto friends
Photo jolie femme ronde et mature 

Visiter la photothèque


Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés
Temps d'éxécution de la page : 3,931 sec

Google Coop CodeS-SourceS Google Coop CodeS-SourceS


Certaines images présentes sur le site (notament certains avatars) sont issues des collections IconShock, donc si vous souhaitez utiliser ces icons vous devez les acheter, ne les copiez pas et ne utilisez pas dans vos sites et applications sans les avoir commandé.