Cool. Je vois que t'as déjà pas mal de choses. L'arduino ce n'est pas vraiment de l'électronique. C'est surtout beaucoup de programmation. C'est pour ça que beaucoup de débutants commence sur arduino et n'utilise pas directement le micro contrôleur.

De rien. Si tu as besoin de plus de détails n'hésite pas. Je répondrai avec plaisir. Mais déjà est-ce que tu as une idée du niveau que tu veux atteindre ? Quels sont tes connaissances en programmation ? En électronique ? Tu parles de le présenter pour la fin de tes études as-tu demandé l'avis de tes profs ? Quel matériel tu as à ta disposition ?
PS: vous êtes d'où ?

Je pense que pour commencer faudrait commencer par faire une petite voiture qui evite les obstacles. Et ensuite rien t'empeche de te joindre à de plus gros projets. Sinon tu risque d'etre tres rappidement décu

Pour la première couche, ce sont les valeurs d'entrées données soit par tes capteurs pour un robot, soit par les données de ton dataset. Pour les couches suivantes, ce sont les valeurs y, calculée par le produit scalaire des entrées et des poids.

pour la première couche c'est ce que retourne calcul(int num, int num2) non ?
pour les autres couches les entrée ce sont les valeur qu'on a calculé avec calcul(int num, int num2) non ?
pour le produit scalaire peut-tu m'expliquer rapidement ce que c'est ?

dsl mais je ne comprends pas comment utiliser le réseau une fois qu'il a apprit. petite question idiote comment on sais si on a plusieurs couches ? c'est en rapport avec les poids ?

oui je me suis apperçu. Je veux dire qu'est-ce qu'on prends en parametre pour savoir combiens d'entrées il faut ... Je pense que je ne comprends pas suffisament tout ça. est-ce que vous connaissez des bouquin ou des tuto avec des exemple  là dessus pour démarer svp ? 

Merci d'avoir répondu. Je m'excuse de la question que j'ai posé.

Je ne suis pas obligé mais c'est que je voulais apprendre à utiliser les neurones et je me suis dis que d'utiliser les neurones pour guider le robot ça peut être intéressant.

merci beaucoup.

J'ai une petite question: est-ce que il y a une limite d'entrée ou pas.

Pas grave. Merci pour la réponse. Quand tu dis:

 

Par exemple, que se passe-t-il pour des poids fixés ?

 

Je n'ai pas compris ce que t'as voulu dire.

et

 

Comment change l'entrée en fonction de la sortie ?

Je sais comment faire en c mais je ne sais pas comment les représenter schématiquement.

J'ai un petit robot que j'ai fais à l'école. Il faut que je le retape mais la carte et tout marche. Merci de ton aide mais pour l'instant je vais déjà voir tout ce que tu m'a dis.

J'ai une petite question: pour apprendre à un robot des phrases est-ce que les réseau de neurones peuvent faire l'affaire ?

OK merci pour ta réponse. Pour l'instant j'essaye de comprendre le tuto d'alp.

je vais essayer de coder un neurone pour la fonction ou mais j'ai une petite question.

dans le tuto il est marqué

 

 

1*0,1+1*0,8 = 0,9 >= 0,5

pour que mon neurone apprenne il faut que je modifie de manière aléatoire 0,1 et 0,8 et les valeurs devront être compris entre 0 et 0,9 non ?

OK Merci mais quand tu dis

 

Tu ne les prends pas, tu les crées. En général, tu peux simplement déclarer des tableaux pour stocker l'activité des couches.

comment je fais pour avoir l'activité des couches ?

 

Le principe d'apprendre comme on le fait (de manière supervisée), c'est que le réseau soit capable de fournir la sortie attendue pour une certaine entrée, ou de trouver la bonne réponse pour une entrée jamais vue (on parle de capacité de généralisation du réseau).

tu veux dire que je dois entrer 0,0 et il doit me sortir les bonnes valeurs ? du coup il faut que je stockes bien les poids et ensuite je me ballade avec mes poids pour trouver la réponse non ?

j'ai fais ça:

#include <stdlib.h>
#include <stdio.h>

int             apprendre()
{
  double        MAX;
  double        MIN;
  double        poid;
  double        poid1;
  int           reseau;

  reseau = 0;
  MIN = 0.01;
  MAX = 0.9;
  srand(time(NULL));
  while ((poid  = rand() / (RAND_MAX + (MAX / MIN))) >= 0.25 && (poid1  = rand() / (RAND_MAX + (MAX / MIN))) >= 0.25);
  printf("poid: %f\npoid1: %f\n",poid, poid1);
  reseau = 1 * poid  + 1 * poid1;
  printf("reseau: %i\n",reseau);
  return (reseau);
}

int             main(int argc, char *argv[])
{
  int   seuil;
  int   reseau;

  reseau = 0;
  seuil = 0.5;
  //printf("%i\n", apprendre());                                                                                                                                                                                                              
  while ((reseau = apprendre()) <= seuil)
    printf("Le neurone n'a pas encore bien appris\n");
  printf("Le neurone a bien appris. %i\n", apprendre());
  return 0;
}

qu'est-ce que vous en pensez ? C'est ça qu'il fallais faire ?

voici le shéma de mon neurone

Que signifie N et M et que faire des poids ?

EDIT: c'est bon pour N et M mais si j'ai 0.2,0.2 c'est égal à 0 ou pas ?

Pour l'instant j'ai fais ça.

http://postimg.org/image/74ym2c5jb/

mais je ne sais pas comment y insérer la fonction qui modifie les poids en fonction de la sortie.

un réseau de neurones c'est des neurones qui sont connectés entre eux par les sorties.

Je me suis excusé parce que vu comme j'ai tourné la phrase on avait l'impression que je demandais qu'on fasse le travail à ma place ce qui n'ai pas le cas.

Je te remerci beaucoup je vais aller voir.

Personne ?

Bonsoir,

j'ai une petite question sur les reseaux neuronaux. Comment faire pour créer un neurone en c ou en cpp ? Je n'ai pas trouvé d'exemple clair qui puisse vraiment répondre à ma question. Mon but serai de faire des petits robots qui puisses apprendre à se déplacer tout seul avec les reseaux neuronaux.

Cordialement et bonne soirée

 

j'ai réessayé et voilà ce que ça donne:

float           dataset[10][3] = {
  {0.0 , 0.0 , 0.0},
  {0.0 , 1.0 , 0.0},
  {1.0 , 0.0 , 0.0},
  {1.0 , 1.0 , 1.0},
  {0.2 , 0.4 , 0.0},
  {0.2 , 0.2 , 0.0},
  {0.5 , 0.5 , 1.0},
  {0.5 , 0.7 , 0.0},
  {0.3 , 0.8 , 0.0},
  {0.7 , 0.7 , 1.0},
};

float           poids[10][3];

void    init()
{
  int   i;
  int   j;

  i = 0;
  j = 0;
  srand(time(NULL));
  for(j = 0; j < 10;j++)
    for(i = 0;i < 30;i++)
      poids[j][i]=(float)(rand() / (RAND_MAX + (0.9 / 0.01)));
}

int     calcul(int num, int num2)
{
  int i;
  int   j = 0;
  float total=0;
  for(i=0;i<30;i++)
    {
      if(dataset[num][j]==1)
        {
          total+=poids[num2][j];
          j++;
        }
    }
  return (total>0?1:0);
}

float calcule_poids(float valeur,int valeur_desiree,int valeur_obtenue,int valeur_entree)
{
  float result;

  result = (valeur + (valeur_desiree - valeur_obtenue) * valeur_entree * 10.0);
  return result;
}

void            apprendre(int num, int num2)
{
  int   i;
  int   j;
  int result;

  result = calcul(num,num2);
  while(i < 30)
    {
      poids[num2][0] = calcule_poids((float)poids[num2][0],num==num2,result, dataset[num][0]);
      i++;
      j++;
    }
}

int             main(int argc, char *argv[])
{
  init();
  int   i;
  int   j;

  i = 0;
  j = 0;
  for(j = 0; j <7;j++)
    {
      for(i=0;i<7;i++)
        {
          printf("t: %i ",calcul(i,j));
        }
      printf("\n");
    }
  /*on fait relier tous les poids avec tous les caractères*/
  for(j=0;j<7;j++)
    {
      for(i=0;i<7;i++)
        apprendre(i,j);
    }
  return (0);
}

c'est bon ? Si ce n'ai pas bon j'ai rien pigé de tout ça

Merci beaucoup pour ton aide. Quand tu dis:

 

 

Si ta fonction calcule sert à calculer l'activité de tes neurones (la valeur de sortie y), il n'y a pas de raison que le dataset entre en jeu. Pour calculer la sortie de ton neurone, tu fais simplement le produit scalaire entre l'entrée et les poids.
Pour deux neurones et deux poids, c'est neurone_sortie = f( poids_1 * neurone_1 + poids_2 * neurone_2 ), mais c'est une bonne habitude d'écrire un code générique avec une boucle.

 

 

ou tu les prends les neurones ?
 

quand tu dis:
 

 

Dans ton main, tu ne fais qu'apprendre, mais tu ne peux pas savoir si ça a marché sans tester ton réseau ensuite (comment il se comporte - càd que vaut sa sortie - quand on lui envoie de nouvelles entrées)

 

comment faire pour tester le réseau ?

 

Pour les poids c'est : float poids[2]; qu'il faut faire ?