begin process at 2012 02 08 21:50:17
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Maths & Algorithmes

 > BIEN EXPLIQUE: EXEMPLE DE RESEAU DE NEURONE

BIEN EXPLIQUE: EXEMPLE DE RESEAU DE NEURONE


 Information sur la source

Note :
9 / 10 - par 1 personne
9,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
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é :11 601 / 1 322

Auteur : acx01b

Ecrire un message privé
Site perso
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

Les Membres Club peuvent 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

 Sources du même auteur

Source avec une capture OPENGL - JEU DE BILLARD EN 3D PAS FINI
Source avec Zip (WIN32) PARSER DU LANGAGE C AVEC YACC
Source avec Zip OPENGL: CLASSE CAMERA QUI GÈRE LE GLULOOKAT
Source avec Zip Source avec une capture SCREENSAVER HYPNOTISEUR
Source avec Zip LABYRINTHE EN 3D

 Sources de la même categorie

Source avec Zip UN EXAMPLE D'APPLICATION EN CUDA DE L'ALGORITHME DE SCAN POU... par oguzaras
Source avec Zip Source avec une capture CHIFFREMENT DE VIGENERE par lajouad
Source avec Zip Source avec une capture ANALYSE SYNTAXIQUE par lajouad
Source avec Zip Source avec une capture STRUCTURE D'UNE MATRICE PAR LES LISTE LINÉAIRE (NON CONTUGUS... par benzarabel
Source avec Zip Source avec une capture DESSINER UNE ARBRE BINAIRE( MODE CONSOLE): par benzarabel

 Sources en rapport avec celle ci

Source avec Zip Source avec une capture MORPIONMAX: UN MORPION 10X10 par ndubien
Source avec Zip MASTERMIND CONSOLE AVEC INTELLIGENCE ARTIFICIELLE -- C (DEVC... par pyronet
Source avec Zip RESEAU DE NEURONE ET APPRENTISSAGE par lebojojo
Source avec Zip Source avec une capture SYSTEME EXPERT (EDITEUR DE RÈGLES + MOTEUR D'INFÉRENCE) par ghassen2
Source avec Zip Source avec une capture INTELLIGENCE ARTIFICIELLE (RECONNAISSANCE DES FORMES EN TEMP... par ciddu42

Commentaires et avis

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.

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).

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+

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.

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 apprentissage avec reseau de neurone [ par resau ] bonsoir, j'ai un problème dans le vecteur caractéristique de réseau de neurone comment l'adapter a mes donnés ,qui sont une matrice qui contient le va


Nos sponsors


Sondage...

Comparez les prix

CalendriCode

Février 2012
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
272829    

Consulter la suite du CalendriCode

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

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 3,058 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales