Je pense que ça peut marcher si le bout des pattes adhère dans une direction de déplacement et glisse dans l'autre (je suis pas bon en mécanique, mais je pense à une espèce de griffe dont le dos est arrondi)
Mais sinon, ce que dit yougo est tout à fait pertinent, si le design est symétrique, il risque de faire du sur-place.
Et sinon, les capteurs, c'est bien. Ne serait-ce que des capteurs de contact en bout de patte pour savoir si elle touche le sol ou pas (ne se concentrer que sur la seule rythmique du mouvement rend à mon avis difficile la tâche de faire marcher le robot de manière robuste).

Merci pour le partage !

Tu n'as pas (encore) eu de souci avec l'usage de la bobine de fil ? Les avis client amazon parlent du fait que la machine renvoie "plus de fil" alors qu'il reste la moitié voir les 3/4 de la bobine, du coup, je me demandais ce qu'il en était vraiment.

Sinon, répondre à tous les sujets pour faire la pub de ton site, c'est assimilable à du spam ...

//////////////////////////////////// LOOP
void loop()

 {
  root.rewind();
  play(root);
 }
 { 
  for(pos = 0; pos < 180; pos += 1)  // goes from 0 degrees to 180 degrees 
  {                                  // in steps of 1 degree 
    myservo.write(pos);              // tell servo to go to position in variable 'pos' 
    delay(15);                       // waits 15ms for the servo to reach the position 
  } 
  for(pos = 180; pos>=1; pos-=1)     // goes from 180 degrees to 0 degrees 
  {                                
    myservo.write(pos);              // tell servo to go to position in variable 'pos' 
    delay(15);                       // waits 15ms for the servo to reach the position 
  }

Ou sont les accolades d'ouverture et de fermeture de la fonction loop() ?

merci pour ta réponse R1D1 mais quand je le fait il y a une autre erreur

sketch_sep02a.cpp: In function 'void loop()':
sketch_sep02a:106: error: a function-definition is not allowed here before '{' token
sketch_sep02a:175: error: expected `}' at end of input

C'est bien de nous donner les lignes de l'erreur, mais vu que le code ne les présente pas, c'est pas très utile.


Quelques commentaires pour essayer de te faire comprendre l'erreur :

//////////////////////////////////// LOOP

void loop()
{
      root.rewind();
      play(root);
}
/* Fin loop */

{ //<-- ? A quoi sert cette accolade ouvrante ?

// Deux boucles hors de la fonction loop, je doute qu'elles soient exécutées un jour ni que le compilo aime ça ...
  for(pos = 0; pos < 180; pos += 1)  // goes from 0 degrees to 180 degrees 
  {                                  // in steps of 1 degree 
    myservo.write(pos);              // tell servo to go to position in variable 'pos' 
    delay(15);                       // waits 15ms for the servo to reach the position 
  } 

  for(pos = 180; pos>=1; pos-=1)     // goes from 180 degrees to 0 degrees 
  {                                
    myservo.write(pos);              // tell servo to go to position in variable 'pos' 
    delay(15);                       // waits 15ms for the servo to reach the position 
  }

Et sinon : http://bit.ly/OI9ic6
Utiliser la fonction loop() - Anglais

C'est difficile de te dire si la SFML te sera utile ou pas ... Perso je l'utilise pour des petits jeux et c'est super pratique ; mais pour faire une interface, il faut définir beaucoup de choses ...
Par exemple, si tu veux des boutons, sliders, etc., je passerai plus facilement par python et WxWidgets (ou autre, mais c'est le gestionnaire de GUI que je connais en python), ou Qt en C++ (je crois qu'il y a des API et python aussi pour Qt.

Je ne sais pas comment est géré l'USB dans SFML (ni si on peut l'installer sur RPi) ; j'ai envie de te dire que si tu la connais bien, ça vaut le coup d'essayer. Tu pourras nous faire un petit retour

Voici le diagramme Fast à l'heure actuelle :

 

 

Diagramme FAST_1.png

 

Les fonctions en verts sont les solutions retenues quand il y a des choix multiples.

Les 2 fonctions en jaune, je les prends pas au sérieux et on verra plus tard ^^

 

Mon premier questionnement se situe sur la méthode de triangulation où je réfléchis encore à la solution adéquate.

 

La problématique est la suivante :

Je vais piloter mes moteurs ce qui va faire avancer le robot. En connaissant la vitesse et le temps écoulé, je peux en déduire une position théorique. Mais c'est une boucle ouverte. Et ayant en tête l'objectif de faire du mapping, je pensais créer un repère cartésien représentant la pièce dans laquelle le robot va évoluer. Sauf que pour compenser toutes les incertitudes, il faut que le robot puisse se recalibrer.

J'ai d'abord pensé à des lasers pour aller chercher la distance par rapport aux murs. Mais ça ne marchera pas (meuble, obstacle quelconque ou encore mur par droit qui fausseront la mesure). 

La solution qui me paraitrait judicieuse serait de placer 2 émetteurs dans la pièces à des points fixes. A partir de là, avec un récepteur sur le robot, je peux trianguler sa position. C'est loin d'être parfait mais ça devrait le faire. Par contre j'ai aucune idée de la difficulté à mettre ce genre de technos en place... Est-ce compliqué ?

Edit : Est-ce vraiment utile ? ^^

Tu touches du doigt le problème du SLAM

Il est possible d'utiliser un laser (ou toute mesure de distance) si tu construis un profil de distance (en faisant tourner le laser par ex.). Ou une caméra. En fait, le principe est que la mesure odométrique (déplacement estimé à partir du déplacement des roues) va permettre de construire une carte d'occupation (à la position p0, le laser mesure le profil pf0, à la position p1 le laser produit pf1, etc ... on obtient la carte en combinant les profils). L'odométrie seule finit par accumuler des erreurs et diverger de la position réelle, mais une mesure "distante" permet de recaler la position : en mesurant le profil actuel et en le faisant correspondre avec la carte, on peut repositionner le robot.

Tu peux chercher des mots-clefs comme "Filtre de Kalman", "Filtre particulaire", "SLAM" sur le sujet. Je recommande l'excellent cours de David Filliat sur la navigation robotique pour en apprendre plus : http://perso.ensta-paristech.fr/~filliat/Courses/index.html

Si tu ajoutes des balises, tu facilites la localisation mais il faut dans ce cas rajouter des balises uniques de partout où tu veux que ton robot navigue.

Solution alternative : deux roulettes sur les hanches et vous utilisez les jambes pour ramper

En tout cas, même si je suis assez pessimiste sur la marche du robot (impressionnez-moi ), bravo pour le travail accompli jusqu'ici !

Super !

Mais y'a eu un rush final ? J'ai regardé vers 10h ce matin et vous étiez genre vers 1500 €

 

En tout cas, bravo, et au boulot !

Il faut une connexion entre les deux machines : un câble ethernet, un réseau wifi, une connexion bluetooth ... n'importe quoi qui permette de mettre les deux ordis en relation et l'échange d'informations. Dans l'absolu, une caméra sur chacun qui regarde l'autre machine et un écran qui affiche un signal codé marcherait.
Donc c'est possible, à condition que les deux ordis soient reliés d'une quelconque manière.

je ne comprends pas comment faire ça.

???
Euh, je suis désolé, mais je ne sais pas comment t'aider si tu ne peux pas faire un schéma de ton réseau de neurones qui illustre sa structure. À ce niveau, il y a quelque chose que tu n'as pas compris dans ce qu'est un réseau de neurones, et son utilisation mathématique.
Si tu ne détailles pas ce que tu sais et ce sur quoi tu bloques, je ne peux t'apporter de réponse. Essaie de nous expliquer depuis le départ ton but, pourquoi utiliser des réseaux de neurones, ce que tu as compris sur le sujet. À partir de là, je pourrais fournir des réponses à tes questions. Il faut aussi que tu me précises si tu comprends mes réponses ou si c'est du charabia. Il est possible que je ne sois pas clair, mais j'ai besoin de le savoir pour vraiment t'aider.

Euh, je ne comprends pas vraiment ce que tu fais.

Le principe de fonctionnement d'un réseau de neurones, c'est d'apprendre à partir d'un ensemble de données. Pour cela, on a généralement une ĥase d'apprentissage, et une phase d'utilisation du réseau ayant appris.
Avant d'aller plus loin, précisons quelque chose : il y a 3 manières d'apprendre.
- apprentissage supervisé : on dit au réseau ce qu'il doit apprendre. On lui donne des couples (entrée, sortie) pour qu'il apprenne par coeur quoi répondre à une certaine entrée. Par exemple, dans le cas du ET logique, on lui donne (entre autres) le couple ((1, 1), 1) qui signifie"si mes deux entrées sont à 1, ma sortie doit valoir 1.
- apprentissage non-supervisé : c'est un peu plus compliqué, on laisse le réseau trouver tout seul la structure des données. En général, on va donner au réseau une entrée, sa couche de sortie va être activée, et on ne garde que le neurone le plus activé. On apprend ensuite à répondre avec ce neurone pour la même entrée (ou des entrées similaires).
- apprentissage par renforcement : celui-là est entre supervisé et non-supervisé. On ne donne plus au réseau ce qu'il doit apprendre, mais on lui indique si ce qu'il a répondu est "bien ou pas bien". Pour une entrée, on renvoie au réseau un signal de renforcement qui est une valeur positive ou négative. Dans le premier cas, on incite le réseau à répondre la même chose pour des entrées similaires, ou au contraire, à ne pas répondre ça du tout.
Dans les deux premiers cas, on se base en général sur une information d'erreur entre la sortie désirée et la sortie obtenue, qu'on utilise pour corriger les poids.

Pour en revenir à ton code : faisons de l'apprentissage supervisé. Pour cela, il faut créer un ensemble de données à donner au réseau. Pour la fonction logique ET, ce seront des couples de valeurs d'entrée flottantes et la sortie binaire associée. Les quatre cas (0,0) (0,1) (1,0) (1,1) plus une dizaine de valeurs d'entrées intermédiaires, ça devrait suffire.
À chacune de ces entrées, tu vas ajouter la réponse attendue. À la fin, tu dois avoir une variable qui contient tout ça :

dataset = {((0,0), 0) ; ((0,1), 0) ; ((1,1), 1) ; ((0.2, 0.7), 0) ; ... } // Dataset sur lequel apprendre (pseudo-code).

Ensuite, tu as ton réseau. Si tu sais faire de la POO, je te conseille de créer une classe, c'est assez pratique. Dans tous les cas, il y a trois éléments principaux à ce réseau :
- ses poids (Nb d'entrée * Nb sortie = 2 * 1 dans notre cas).
- sa règle de calcul de l'activité de sortie (l'activité de chaque neurone de sortie est la somme pondérée des entrées par les poids, passée par une fonction non-linéaire ou seuillée - dans notre exemple, on seuille à 0.5)
- sa règle d'apprentissage. On peut se contenter de Widrow-Hoff, qui nous donne comment on modifie chaque poids w_i en fonction de l'erreur de prédiction (valeur de sortie désirée - valeur obtenue). C'est la partie V du tuto d'Alp.

Donc pour définir ton réseau, il te faut un tableau N*M de poids, une fonction qui l'utilise pour calculer la sortie, une fonction qui le modifie pour tenir compte de l'erreur (ou un attribut et deeux méthodes dans une classe).
Au début, on initialise les poids à des valeurs aléatoires (on peut aussi les initialiser à zéro). Cela représente le fait qu'on ne sait pas quelle fonction on va devoir apprendre. C'est normal, c'est la beauté d'un tel système : il peut apprendre à peu près tout ce qu'on veut, tant qu'on lui donne des exemples (et que le réseau est capable d'approximer la fonction, voir l'exemple du XOR du tuto de Alp).

On a donc un dataset, un réseau, on peut commencer à apprendre. Pour cela, on va tirer au hasard un exemple du dataset, et voir ce qu'il donne dans notre réseau. On appelle donc la fonction de calcul de la sortie avec l'entrée de l'exemple, et on obtient une valeur de sortie.
Au début, comme on a initialisé les poids aléatoirement, il y a de fortes chances que la sortie obtenue soit différente de la sortie désirée. Ça n'est pas grave, puisqu'on va de toute façon appeler la fonction d'apprentissage.
On calcule l'erreur, on modifie les poids, et la prochaine fois qu'on aura la même entrée, il est plus probable que le réseau réponde la bonne valeur.
Et hop, on peut recommencer ces deux étapes en tirant un nouvel exemple et en répétant les étapes précédentes.

Et quand est-ce qu'on s'arrête ? Pour ça, on va définir une valeur de convergence : tant que cette valeur est différente de zéro, on apprend (puisque ça veut dire qu'il y a e une modification à faire, et qu'on n'avait pas approximé correctement la fonction). Cette valeur, c'est simplement la somme des modifications sur les poids.
En pratique, on ne vérifie pas qu'elle vaille zéro, mais qu'elle soit inférieure à une valeur très faible "epsilon".

Maintenant qu'on a finit d'apprendre, on ne va pas arrêter notre programme tout de suite, ça serait dommage d'avoir faire apprendre notre réseau pour ne pas l'utiliser.
Ici, on va donner des entrées à notre réseau, et voir ce qu'il répond. Dans notre cas, on peut demander à l'utilisateur de saisir deux valeurs au clavier, et afficher la sortie. Si tout se passe bien, on devrait avoir une sortie qui reproduit la fonction ET.

Tu peux regarder le tuto de Alp sur developpez.com pour les généralités : http://alp.developpez.com/tutoriels/intelligence-artificielle/reseaux-de-neurones/

Combien d'entrées ? Ça dépend de ton problème : pour de la reconnaissance de caractères (OCR), l'entrée du réseau est une image contenant le caractère, il y a donc autant (ou moins) de neurones d'entrée que de pixels. Pour un robot, ça dépend beaucoup de ses capteurs : si tu as deux capteurs de distance, tu peux avoir deux neurones dont l'activation est fonction de la donnée de distance mesurée, ou tu peux discrétiser la distance mesurée en "court, moyen, long" et affecter un neurone pour chaque catégorie (donc 6 neurones d'entrées).
Plus tu mets d'information en entrée (image de grande dimension, plusieurs capteurs de distance, vitesse mesurée des roues, ...), plus tu augmentes la dimension de l'espace d'entrée. Tu as donc une information plus riche, mais ça rend potentiellement l'apprentissage plus long.
À toi donc de choisir quelles mesures tu veux donner à ton robot. Il faut savoir aussi que plus tu fais de pré-traitements sur ces entrées (extraire des contours d'une image), plus tu rends l'information accessible au réseau, mais plus tu as de chances de biaiser son apprentissage et son comportement (donc de le pousser à faire des choses que tu lui as imposé, et pas de les découvrir lui-même, ce qui est le but de l'apprentissage automatique).
En sortie, tu dois décider des grandeurs que tu veux contrôler. Pour un robot, ça peut être les vitesses motrices, les angles des articulations, etc ... pour l'OCR, les neurones de sortie peuvent être les classes que tu veux reconnaître (ici, une classe est un caractère - "1", par exemple).

Le nombre de couches détermine le niveau d'abstraction que tu peux extraire de tes données. Un exemple classique est celui de la détection de contours par réseau de neurones : dans la première couche, tu as la valeur (0 ou 1) des pixels de l'image. Dans la couche suivante, tu peux apprendre/fixer des poids pour que tes neurones réagissent à une variation de la valeur des pixels (un contour donc). Mieux vaut commencer par une seule couche pour bien comprendre ce qu'il se passe.
Pour t'entraîner, tu peux essayer de faire un petit réseau qui apprend à se comporter comme des fonctions logiques ET/OU ... Et quand tu testeras le OU EXCLUSIF, tu devrais te rendre compte d'un problème (voir l'article d'Alp qui explique ce cas et pourquoi une deuxième couche est nécessaire).

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 ?

Est-ce que tu as bien compris en quoi consiste un réseau de neurones ? Si non, essaie d'expliquer ce que tu as compris pour que je puisse savoir quelles informations te manquent / sont inexactes.

N et M sont les tailles en nombre de neurone de tes entrée et sortie. Comme les poids connectent chaque entrée à chaque sortie, il y a donc N*M poids. Ce sont les poids qui permettent l'apprentissage en faisant des associations entre entrée et sortie.
Pour l'entrée (0.2, 0.2), ... c'est toi qui voit. Si tu veux que ton réseau apprenne à répondre 1 pour cette entrée, tu peux le donner en exemple dans ta base d'apprentissage. Si on veut faire apprendre la fonction ET, on peut décider (mais c'est vraiment TON choix) que le réseau de neurones doit considérer que ses entrées valent un 1 logique si leur valeur est supérieure à 0.5 (comme on fait souvent pour passer d'un signal analogique à un signal numérique en électronique : on place un seuil pour rendre binaire des valeurs continues).
Donc pour l'entrée (0.2, 0.2), la sortie désirée sera 0. Ce qui est puissant dans les réseaux de neurones (et les méthodes d'apprentissage automatique en général), c'est que ça n'est pas à toi de te casser la tête pour trouver comment le réseau doit réagir : c'est les données d'exemple qui vont déterminer ce comportement. Si tes données sont des exemples de fonctionnement de la fonction logique ET ou OU, le réseau trouvera lui-même les bons poids (aussi appelés paramètres) pour réagir comme ces fonctions.

Je te remerci beaucoup je vais aller voir.

N'hésite pas à poser des questions ici-même si tu ne comprends pas certaines choses. J'ai utilisé un réseau à poids fixés dans mon robot Froggy (ce qui en fait un véhicule de Braitenberg - voir démo en fin de post) qui ne fonctionne pas trop mal, cependant, une seul capteur de distance est à mon avis insuffisant. Tu as déjà un robot pour le faire tourner ? Ou tu comptes travailler en simulation ?

Bon courage en tout cas !

Démo de Froggy (et post de blog correspondant) :

voici le shéma de mon neurone

Euh, quand je parlais d'un schéma, je parlais d'illustrer les différentes variables : indiquer les entrées, les poids, la non-linéarité, la sortie, les informations qui rentrent et qui sortent, pour que tu puisses comprendre à quoi le réseau correspond.

Salut,

c'est un sujet de recherche sur lequel travaillent les académiciens actuellement. De bon résultats ont été obtenus notamment grâce à du "deep learning". Le problème étant que la majorité de la documentation sur le sujet est en anglais. Tu peux chercher "NIPS 2015", "ICML 2015" qui sont des conférences d'apprentissage automatique. Tu as un résumé de la conf' ICML ici : http://blog.heuritech.com/2015/07/20/heuritech-icml2015/(anglais)

Salut

 

Désolé, j'ai eu peu de temps pour répondre depuis août.

 

Oui le schéma que je te suggère de faire ressemble à celui de ton lien. Le but, c'est que pour ton cas, tu fasses un schéma similaire, avec les entrées/sorties que tu veux utiliser. Tu peux aussi le faire pour l'exemple d'une fonction logique pour t'entraîner. Le but, c'est que tu te poses des questions sur ce qui se passe vraiment dans le réseau et comment sont déterminées les différentes valeurs. Que tu écrives les équations pour comprendre les traitements sur les variables. Si tu comrpends l'algorithme, le coder ne devrait pas poser de difficultés.

 

Par exemple, que se passe-t-il pour des poids fixés ? Comment change l'entrée en fonction de la sortie ? etc.

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

Dans le nombre que tu peux en mettre ? Oui et non.
- Non, parce que le principe reste le même indépendamment du nomibre d'entrées. Une entrée de plus rajoute simplement des poids de connexion en plus vers la sortie. Ça dépend du modèle, mais la sortie du neurone est calculée en faisant le produit scalaire entrée/poids, et ça s'accomode plutôt bien d'une taille variable.
- Oui, parce que plus tu augmentes la taille de ton entrée, plus tu augmentes le nombre de poids nécessaires, et plus tu vas mettre d'information en mémoire. On prend en général des variables de type "float" en C++, si tu as N neurones sur ta couche d'entrée et M sur ta couche de sortie, tu auras NxM float à garder en mémoire (soit NxMx4 octets). Tu multiplies également le nombre d'opérations à faire pour les mettre à jour.

Après, les gens qui travaillent sur des images envoient souvent 320x240 = 76800 pixels en entrée, ce qui est quand même pas mal comparé à un réseau à une dizaine d'entrées qui pourrait contrôler un robot.

N'hésite pas à nous montrer ce que tu fais, ça permet de donner un contexte aux questions et d'être plus précis dans la réponse.

Salut !

Tu peux créer un réseau neuronal comme n'importe quel programme informatique : en écrivant le code correspondant, ou en utilisant une librairie qui le fait pour toi.
Dans le premier cas, il faut bien évidemment comprendre les algorithmes (quel modèle de neurone, quel type d'apprentissage, quel type de mise à jour).
Dans le second, tu peux chercher sur Github, il y a plein d'implémentation (sûrement de qualité variable). Si tu fais du python, tu peux chercher du côté de scikit-learn qui est une référence pour le machine learning en python. Je ne lui connais pas d'équivalent en cpp.

Tu peux aussi regarder le travail d'Andrej Karpathy sur les Deep Neural Network, plutôt à la mode en ce moment : https://github.com/karpathy

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.

Je ne comprends pas ta question. Qu'appelles-tu "définir les réseaux neuronaux" ?
Ce qu'il faut déterminer, ce sont les entrées et sorties que tu vas donner à ton réseau, et le nombre de couches de neurones, la taille de chaque couche, la règle d'apprentissage si tu en mets une.

Avant de parler de "personnalité", il faut penser aux comportements que ton robot doit avoir. Mieux vaut commencer par des choses simples, des comportements attirés par la lumière ou repoussés par les obstacles (on peut faire le parallèle avec des émotions comme le désir ou la peur).
Ça peut se faire sans apprentissage. Pour faire des choses plus compliquées, il y aura besoin d'apprentissage, mais ça risque d'être assez long.

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

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.
 

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 ?

Oui. Mais c'est le principe du réseau de neurones : on créé les neurones, on les connecte entre eux, puis on fait apprendre le réseau pour pouvoir l'utiliser ensuite.

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 ?

Commence par faire un schéma de ton réseau, en notant les entrées / sorties / poids, et montre-nous ça, ça devrait t'aider à comprendre (avant toute programmation, il faut avoir une idée de ce que tu veux programmer, comprendre l'algorithme et ses spécificités).
La couche d'entrée, ce sont les neurones qui codent les valeurs d'entrée. Ils n'ont pas de poids, leur activité est directement égale à la valeur de la donnée d'entrée.
Par exemple, dans le cas d'une fonction logique OU, pour l'exemple ((1, 0), 1) d'un dataset, l'entrée est (1, 0), donc l'activité d'un des neurones de la couche d'entrée est 1, celle de l'autre est 0.
Une fois l'entrée fixée, tu calcules l'activité de la couche suivante en utilisant les poids et les entrées de la couche précédente.
Produit scalaire : https://is.gd/uqQ3Ym

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

Euh, non.
Un réseau de neurones artificiel est un ensemble de neurones artificiels (qui sont des unités de calcul simple) connectés entre eux par des poids. Chaque neurone a un niveau d'activité, qui correspond à la valeur de sortie y = f( produit_scalaire(poids, entrée) ), avec f une fonction mathématique (souvent non-linéaire et dérivable, mais passons).
Le principe d'un réseau, c'est d'avoir une "couche" de neurones, non-connectés entre eux (dans le cas simple), connectée par les poids à une autre couche de neurones. L'entrée d'un réseau génère de l'activité sur la première couche, l'activité générée passe par les poids pour provoquer de l'activité dans la deuxième couche, et ainsi de suite si on rajoute d'autres couches de neurones.
 

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},
};

Ça, ok : on a 10 exemples, chaque exemple contient les deux informations d'entrée et l'information de sortie. L'ensemble des exemples correspont au comportement d'une fonction logique ET, sauf pour le cas ((0.5, 0.7), 0.0), mais on peut vouloir apprendre une fonction différente.

float           poids[10][3];

Là, pas d'accord : pourquoi tes poids font 10x3 ? Un réseau qui prend deux entrées et renvoie 1 sortie n'a besoin que de deux poids.

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)));
}

Je ne comprends pas à quelle valeur tu initialises tes poids. Un simple "rand() % valeur maximale" suffit à mon avis, par contre, les poids peuvent être négatifs, donc ça devrait rentrer en compte dans l'initialisation (pour ne pas biaiser l'apprentissage).

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);
}

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.

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;
}

Ici, c'est presque bon : pourquoi faire * 10.0 à la fin ?
Si tu veux simplifier un peu cette fonction, tu peux ne lui faire calculer que la variation du poids, c'est-à-dire "(valeur_desiree - valeur_obtenue) * valeur_entree".

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++;
    }
}

Pourquoi faire un test num==num2 dans l'appel de ta fonction ? Déjà, tu vas renvoyer un booléen qui devrait faire un warning à la compilation, et ça n'a pas vraiment de sens. Ta variable j ne sert pas ici.
Je pense que tu n'es pas loin de comprendre, mais il manque un tout petit peu.

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

Attention, j'ai l'impression que tu as un peu de mal avec la portée des variables. Il vaut mieux déclarer principalement des variables locales, et faire des return/passage en argument pour les informations que tu veux utiliser dans plusieurs fonctions.
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)

ou tu les prends les neurones ?

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 faire pour tester le réseau ?

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

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

Pour cet exemple où on veut apprendre la fonction ET, oui, c'est comme ça que tu déclares un tableau de taille 2x1.