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

c'est ça que tu veux que je fasse ?

https://upload.wikim...el_francais.png

Pour de ce que j'ai compris des réseau c'est t'as des entrées par exemple des capteurs et une sortie. Les neurones sont connectés entre eux grâce aux poids. Ce que je ne comprends pas c'est comment réutiliser le réseau une fois que j'ai bien appris. J'aimerai utiliser un réseau neural pour que mon robot puisse ce déplacer tout seul et je pense l'utiliser pour lui apprendre des ordres puis à long terme à répondre et peu être parler mais je me fixe des objectif. Pour l'instant j'aimerai créer un petit réseau pour que mon robot puisse ce déplacer. j'espère que j'ai été clair. En tout cas je te remercie de tout ton aide.

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 ? 

J'ai une petite question maintenant que je sais combien j'ai d'entrées et combien j'ai de sortie et que je connais les différentes valeurs. Comment je fait pour choisir le nombre de couche de mon réseau la méthode d'apprentissage et comment je le met en code.

Cordialement.

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 ?

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 ?

Personne ?

pour les réseaux neuronaux j'aimerai les utiliser pour créer une petite intelligence artificiel qui est ça propre "personnalité". cad qu'il puisse avoir un semblent de personnalité. Comment définir les réseau neuronaux. c'est quelque chose comme ça que je veux faire https://www.youtube....h?v=qZqqdqiKw3o à 25 minutes en moins complexes bien sûr. 

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

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 ?

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

je ne comprends pas comment faire ça.

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

personne ?

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 ?

Donc par exemple pour un robot mobile auquel je veux qu'il apprenne à avancer et détecter les obstacles il faut

En entrées:

1. Valeur capteur gauche
2. Valeur capteur avancer
3. Valeur capteur Droite

En sortie

1. Vitesse moteur Droit
2. vitesse moteur Gauche

Les valeurs d'entrées sont  entre 0 et 1.

Les valeurs de sortie sont entre 0 et 1.

tant que Valeur capteur Gauche est supérieur à 0,2 vitesse moteur gauche = 1

Si Valeur capteur Gauche est inferieur ou égal à 0,2 vitesse moteur gauche diminue en fonction de l'angle qu'on veut

tant que Valeur capteur Droit est supérieur à 0,2 vitesse moteur droit = 1

Si Valeur capteur Droit est inferieur ou égal à 0,2 vitesse moteur Droit diminue en fonction de l'angle qu'on veut

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 ?

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.

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.

OK d'accord merci beaucoup

Je te remerci beaucoup je vais aller voir.

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 ?

voici le shéma de mon neurone