...

Bien que je ne l'ai jamais fait, voilà comment j'aurais tenté de procéder si j'avais voulu créer un botnet (ce ne sont que des idées).

...

Je parle d'un chatbot, bien sur, pas d'un botnet.... c'est chiant de pas pouvoir editer...

Non non non ce n'est pas du tout con ce que tu dis et c'est même bien vue. Cependant c'est difficilement applicable mais cela est fonction du langage.
Par exemple, si tu prend des langages comme Delphi ou C++ c'est pratiquement irréalisable car il sagit de programmes compilés. Autrement dit, tu saisi un algo en langage utilisateur (for, while, if ...etc.) et un compilateur se charge de les convertir en langage machine (010001110) sous la forme d'un executable "directement" exploitable par le processeur. Ainsi donc un "programme" capable de se réécrire lui même devrait présenter de multiples sous programmes qui seraient réécris en temps réel par un programme "maitre" puis compilés dans la foulées pour être exploitable par le programme maitre. Si en théorie cela n'est pas impossible, en pratique cela est complètement irréalisable car la compléxité du programme maitre serait telle que les temps de réponse (a moyen terme) seraient inadmissible pour un système "réactif" même en imaginant que l'informatique connaisse une progression exponentielle. De plus, l'écriture d'un tel programme maître nécessiterait des ressources en ingénieurie science-fictionnesques et serait, en pratique, in-débuggable car des milliers de sous programmes seraient modifiés en temps réel. Donc pour les langage compilé, il faut oublier ce principe tant pour des raisons de performance qu'en terme d'ingénieurie. Il existe cependant un échappatoire grace a la programmation orientée objet. En fait, ce type de programmation se rapproche fortement du principe du programme maitre et des sous programme a ceci pret qu'il fait appel a des objets disposants de leur propres propriétés. En fait, un objet est un groupe de variables et de procédures répondant à un modèle générique (défini par le développeur) mais pouvant être initialisés et utilisés de façon différentes (par exemple le champs texte dans lequel j'écris est un composant qui possède différentes propriétés comme par exemple la couleur du texte ou sa taille -> Ce sont les variables. Mais il possède aussi un nombre données de fonction comme par exemple la combinaison de touche Ctrl+A qui sélectionne tout le texte. On pourrait trés bien imaginer réécrire cette fonction pour qu'elle ne sélectionne que les majuscules (fonction) si le texte est écrit en gras (variable de l'objet) et que les minuscule (fonction) s'il est écris en rouge (variable). Mais poussons plus loin. Imaginons désormais que notre champs texte possède un ensemble de fonction (faire clignoter en rouge les lettres E, transformer en smiley tous les espace...etc) et un ensemble de vrariables qui le définisse (taille du champs texte, couleur, image de fond...etc). On peut alors faire en sorte que l'execution des fonction ne soit pas liée "par le code" aux variable (qui peuvent être le résultat de fonction) mais par un fichier texte qui dit si la variable machin vaut tant alors lancer telle ou telle fonction. Enfin, imagine une fonction capable de "pondérer" l'adéquation du lancement de telle(s) fonction(s) par rapport a telle(s) variable(s) (parce que les performances machines seront meilleurs, ou que l'utilisateur a cliqué sur un bouton comme quoi il est contente...etc) et de l'écrire dans le fichier ini de liaison si cette pondération est plus interressante (on peut même garder une trace de la progression en datant les combinaisons). dans ce cas, nous avons une machine qui tendra a s'adapter au mieux aux besoins et donc capable d'apprendre. D'ailleurs, au final, a un stimuli simple, la machine en arrivera a élaborer un déclenchement en série (ou en parrallèle) de fonctions simples qui finiront par aboutir à un résultat complexe (comme s'il sagissait d'une sorte de super fonction unique constituée des autres). C'est en exploitant cette méthode de développement que nous programmons Caliban. J'espère que j'ai su m'exprimer correctement.


mais il existe d'autre langages que ceux compilés. ce sont les langages interprétés ! Ces derniers sont souvent désignés sous le nom de Script car ils ne sont pas en eux même directement compréhensible par la machine. Il leur faut pour cela un interpréteur, ou traducteur qui converti en langage machine en temps réel le Script. Et c'est exactement ce que fait notre Internet Explorer ou Firefox préféré. les pages d'un site sont écritent par exemple en javaScript, en html ou ce que tu veux mais ces fichiers ne sont pas utilisables par l'ordinateur. il faut pour cela un autre programme, notre fameux programme maitre, qui soit capable de dire "bon alors ce script dit de faire ca donc je vait lancer telle ou telle procédure" qui sont intégrée d'office dans l'interpréteur. C'est d'ailleurs ces fonction présentent dans l'interpréteur qui sont les fameuses "mise a jour", "pluggins" ou "drivers" que l'ont doit sans cesse installer afin de faire evoluer notre interpréteur pour qu'il soit en phase avec les besoins grandissants des langages interprétés. Tu remarqueras donc que le concept se rapproche un peu de la programmation objet car il y a un programme maitre qui manipule un ensemble de notions. A ceci pret qu'en objet, ces notions sont capable d'executer -elles même- des fonction sans faire appel a leur programme maitre. Ainsi, on pourrait trés bien imaginer un interpréteur suffisement abouti et un script suffisement soffistiqué pour qu'il soit capable de générer lui même des script exploités par l'interpréteur. Mais en pratique cela ne fonctionne pas correctement sauf pour des taches simples car les régles de syntaxe des script sont trés strictes (plus qu'en programmation compilée). je ne vais pas entrer dans les détails a ce sujet mais concrètement, il est difficile d'imaginer un script capable de générer des script servant de support a un apprentissage non prévu par le programmeur.

Pour résumer, ta suggestion est tout sauf idiote mais elle peut se traduire dans la pratique sous plusieures forme et, la plus appropriée (pour un système capable d'apprendre) et pratique à mettre en oeuvre est selon moi la programmation orienté objet.

J'espère avoir répondu a ta question

Juste une remarque sur les langages :
Python est un langage interprété orienté objet. Je l'ai déjà utilisé pour executer un sous-programme écrit en dehors du programme, (et meme écrit après que le programme principal ait été activé) c'est donc tout a fait possible. Il possède une instruction "eval(chaine_de_caractères)" permettant d'exécuter tout code écrit à la volée ou pioché dans un fichier. Il possède aussi des classes dédiées à la manipulation de morceaux de codes python.

Bon, en reposant à plat, ça donne ça :

La structure des tables me parait bien. La certitude bornée entre 0 et 5 compris. Quand une phrase est entrée elle commence avec une certitude de 2.

Des entrées possible pour débuter l'apprentissage seraient :

verbe être mot
être être mot
être être verbe
sujet être mot
...

Je fais le choix de parler sans conjugaison ni articles volontairement, puisque le systèeme apprends tout juste la grammaire. On commence par simple.

Le déroulement que j'immagine maintenant avec ces entrées est le suivant :

"verbe être mot" est stoqué dans la table vocabulaire, avec une certitude de 2, comme toute entrée par défaut. Puis on lance un module de recherche de cohérence, qui compare les données des tables (mettons 10 données ayant un lboc de lettre consécutif en commun, en commençant par chercher dans les tables + complexes) avec la nouvelle phrase. Il n'a rien a faire.

"être être mot" est stoqué de la même manière. La recherche de cohérence se trouve avec 2 mots similaires contenants des espaces. Elle détecte que les contenus après le premier espace sont identiques, elle tente une cohérentisation de la chose :
dans la table vocabulaire :
"verbe être mot" prends -1 en certitude (sauf si ça le fait passer à zero)
"être être mot" prends -1 en certitude (sauf si ça le fait passer à zero)
"verbe", "être", "être mot" sont créés comme mots de note 1
dans la table sens :
"être mot" est créé avec la certitude 2 et l'arité 1.
dans la table instance :
"être mot", "verbe", 2
"être mot", "être", 2
tout ça est une étape, un cycle de cohérence, il y a 10 cycles a passer comme ça.

le résultat du second cycle pourrait être :
vocabulaire :
"verbe", "être", "mot", "verbe être mot", "être être mot", "être mot", tout à 1
sens :
"être mot" à 1, "être" à 2 (par comparaison entre "être mot" et "être") avec une arité de 2 ?
Instance :
...

puis les autres cycles ne font rien, y'a plus rien a déduire.
et on continue avec "être être verbe"...


Voilà, si quelqu'un veut coder ça pour essayer de voir ce que ça donnerait

En fait, je pense que ca ne donnerai rien :aum ieux ce système permettrait d'apprendre le sens de certains verbes, et d'apprendre peut être partiellement une grammaire, mais il n'apprends pas plus le sens de la pluspart des mot. C'est je pense le point crucial : que la machine puisse appréhender le sens des mots, pour faire une IA.

Bonjour,

Je me demandais : quelles méthodes utilisez-vous pour apprendre à vos robots ? J'ai fait très peu de robotique, aussi tout ce qui suit est purement théorique... En voulant faire des robots qui apprennent, il me semble qu'on essaye de reproduire la façon dont nous humains avons appris : répétition des gestes, unicité de l'apprentissage (une tâche à la fois), etc. C'est à la fois relativement puissant et très long (on est majeur à 18 ans !). Si on veut réduire le temps d'apprentissage d'un robot, il me semble qu'il faut inventer une nouvelle pédagogie plus adaptée. Dans ma tête ça passe par l'utilisation d'un simulateur pour démultiplier les expériences du monde réel et accélérer l'apprentissage.

Par ailleurs, je ne sais pas si je dis une hérésie, mais je me demande toujours si ce ne serait pas plus pratique de mettre à l'extérieur du robot toute la partie calcul, et relier "l'âme et le corps" par wifi ou affilié. Les processeurs actuels ne sont pas si puissants que ça, et pour le travail sur l'intelligence artificielle, tout se passe en labo, donc la dépendance au wifi ne serait pas pénalisante.

Personnellement, je n'ai pas de robots, je m'intéresse à l'aspect programmation pure. Donc je ne connait pas les capacités de l'embarqué et je pense de toute façon à un controle par ondes, comme tu dit.

Pour l'autre question, oui, l'apprentissage est long et on pense en général à un apprentissage par l'expérience. Mais une machine peut être dupliquée, une fois l'apprentissage effectué. Il suffit de recopier les données de l'apprentissage (plus ou moins une petite période d'adaptation, car aucune machine n'est physiquement absolument identique). Quand à une pédagogie plus appliquée, de toute facon la pédagodie utilisée va déjà être faite en fonction du type de capacité d'apprentissage qu'on donne à la machine, c'est donc déjà plus ou moins ce qui est fait au cas par cas.

Bon, j'ai lu a peu près tout le fil, et la question n'est pas simple. (J'ai suivi il y a longtemps un cours de traitement automatique du langage, mais je n'en ai que des souvenirs vagues)

Bien que je ne l'ai jamais fait, voilà comment j'aurais tenté de procéder si j'avais voulu créer un botnet (ce ne sont que des idées).

-Pour ce qui est des différentes phases d'analyse sémantique des phrases, en entrée :
L'utilisation de grammaires formelles (du genre ... Phrase = Sujet Verbe [Complément] .... Sujet = Nom_Propre .... Sujet = Article_Personnel ... Sujet = Article Nom_Commun ... etc..) pour créer des arbres sémantiques me parrait être un bon début.
On peut utiliser la classe sémantique des mots pour leur reconnaissance. La grammaire peut être donnée explicitement dans le code source.
On sait cependant que ça pose des problèmes de pluralité de sens dans certains cas ("Le chef sale la note" peut être vu comme 2 arbres sémantiques différents - sale en verbe ou sale en adjectif).
Pour distinguer parmis les 2 arbres sémantiques, il faut faire une analyse contextuelle de la phrase (par rapport au reste du texte) et pour cela il faut connaitre le sens des mots utilisés.
Avec ce contexte, on peut (je pense) choisir l'arbre sémantique et dire que la phrase à été comprise.

-Pour ce qui est du traitement de l'arbre sémantique :
Dans tous les cas, ce qui compte, c'est la structure de données utilisées pour représenter la connaissance.
On pense d'abord à une Base de données relationnelle. (Il y a de nouveaux concepts emergents de bases de données non relationnelles, c'est peut être intéressant ici, a réfléchir.)
Les tuples sont des mots, OK.
Les Tables sont des classes sémantiques, OK,
Mais quelles sont les relations de cette BD ?
le moteur d'inférence nous indique une de ces relation : l'implication. Une autre qui peut parraitre évidente est le fait d'être, et une autre celui de posséder. Il y en a d'autres, comme être_identique_à, (ce qui donne comme sens à être celui de l'inclusion dans un ensemble).
le problème, ici, c'est que être, posséder, impliquer sont aussi des verbes.
Cela veut dire qu'on se dirigerais sur des tables_classes_sémantiques, et sur des tables_relations_entre_les_classes_sémantiques_et_des_verbes. En fait, vers une méta BD (au niveau relationnel).
Rien que l'établissement de cette méta BD est très complexe et demanderais un travail spécifique. Mais elle permettrait d'apprendre à un autre niveau qu'un simple apprentissage de nouveaux mots. Elle créerai un apprentissage du sens.

Pour le système d'apprentissage :
Il y a 2 axes : la compréhension de la phrase (passage du sens de la DB vers la phrase), et l'acquisition de nouvelles connaissances à partir de la phrase (passage du sens de la phrase vers la BD).
La part de compréhension/acquisition, c'est le lot de tous les systèmes d'apprentissage. Ici cependant elle est facilité, parce que la machine apprends à chaque phrase (ne serait-ce que la justesse sémantique de ladite phrase).
On peut immaginer adjoindre un champ dans les tables avec une note de confiance dans le nouveau mot ajouté, et augmenter cette note de confiance quand le mot est réemployé. Idem pour les relations re-confirmées.
Lors d'un echec de logique entre ce que dit une personne et la base de connaissance, je proposerai de mettre en place un méchanisme de disjonction sémantique d'un mot (par exemple le verbe être, qui doit avoir beaucoup de sens différents).
Ce pourrait être un méchanisme qui demande confirmation de tous les faits de cette incohérence, puis demande la différence sémantique entre les différents sens. S'il la comprends, alors distinguer les 2 sens comme 2 mots différents, s'il ne la comprends pas, alerter le dévellopeur. (et a nous d'améliorer le système pour la prendre en compte)

-Pour la génération d'une réponse :
ben, on peut cibler des questions qui touchent les nouveautées, ce que vos botnets font déjà.
En revanche, je n'aime pas l'idée de disposer de réponses toutes faites. Je préfère une sortie incohérente, quitte à devoir comprendre pourquoi elle est incohérente et pouvoir corriger la source de cette incohérence.
J'avoue que je n'ai pas trop réfléchi à cette partie.

Je sais bien que c'est très incomplet, mais je vous livre juste mes réflexions. qu'en pensez vous ?

-autres idées :
Considérer que la grammaire formelle utilisée est quelque chose qui doit aussi être appris. Je pense que je commencerai par là, en fait. Modéliser la grammaire sémantique dans la BD, ça doit dépoter. Mais comment intégrer cet apprentissage ?
En relisant je me rends compte que le seul sens que j'ai appris avec ce système, c'est celui des verbes concrets. Comment apprendre celui des noms propres, sinon en ayant des interfaces autres (yeux, représentation spatiale) ?

Comme je lache pas facilement une idée, voilà un premier jet de BD

Vocabulaire : Certitude, Mot
chaque mot connu

Sens(relationnel) : Certitude, Mot, Arité
chaque mot entrainant une relation (en général un verbe, avec les différentes possibilités d'arité de ces relations (soit un chiffre, soit un code (0?) signifiant que ce nombre est variable)

InstanceDeSens : Certitude, Mot-Sens, Mot-Sujet, [Mot-Secondaire, indiceInstance]
mot-secondaire est optionnel, et pour les arités supérieures à 2 on utilise indiceInstance pour identifier les nombreux mot-secondaires de la même instance


Si on veut intégrer la grammaire dans l'apprentissage, il faut distinguer ces 2 phrases :
"Tu" est un mot
et
Tu est un homme

Le premier est grammatical
Le second est sémantique

Bon, faut que je file.

Salut.

Ton programme va devoir avoir plusieurs couches. La première sera la couche matérielle; celle qui te donnera les résultats des capteurs (du genre "luminosité à gauche = 35"). La seconde sera une couche symbolique; qui transformera ces données physiques en données symboliques, comme dit plus haut (du genre "il fait jour"). Il te faudra au moins une troisième couche, décisionnelle. C'est celle-ci qui déterminera le but actif. (Comme il fait jour et que mes batteries faiblissent, je décide de faire la sieste au soleil). Et encore une 4ème couche, applicative (quelles actions élémentaires correspondent à cette décision ?)

D'une manière générale, plus tu ajoutera de couches abstraites (par exemple, un niveau 3,5 "prévisionnel", ou un niveau 2,5 de "mémoire"), plus ton robot sera "intelligent".

La première couche est facile à faire, elle est linéaire, la seconde est déjà plus complexe. Est-ce que tu veut faire un apprentissage ou est-ce que tu veut coder en dur la détermination de symboles ? Coder en dur est beaucoup plus facile, mais cela introduit un énorme biais dans l'intelligence, c'est ton analyse qui déterminera beaucoup de choses. La troisième couche, ben.... à toi de choisir le système de décision, un système expert (ensemble de règles dont l'ordonnancement est déterminé par apprentissage) ça peut être pas mal pour un début (un système de but par fonction objectif globale ne te mènera à rien d'intéressant, il n'y aura aucune "intelligence"). Et la 4ème couche ? À peu près comme la seconde plus la première, dans l'autre sens.

Si tu sépares bien tes couches, tu pourra quand tu aura un résultat changer le contenu de l'une d'elle indépendamment des autres pour améliorer ton robot. C'est pas forcément évident à faire au début mais tu y gagnera beaucoup plus tard.

Enfin, un des problèmes à résoudre c'est comment partager le temps d'exécution de ton proc entre les différentes couches. Si tu peut faire un thread ou un processus par couche, ce sera bien. (Je n'y connait rien en robotique, je ne sais pas ce qu'il est possible de faire au niveau du multithreading, mais presque tout les langages gèrent ça maintenant en info, donc j'imagine que ça devrait pas être un problème).

Et pour finir, le dernier problème : comment vas tu faire communiquer tes couches entre elles ? Un système de mémoire des résultats internes des couches, écrites par la couche n et lus par la couche n+1, me parait pas mal, mais y'a certainement d'autres solutions.

Bon courage, y'a du taf....

Oulalala... J'ai l'impression que vous mélangez tout la !

Alors concernant le C/C++ :
Arduino EST DU C++, vous avez donc acces à toutes les librairies STANDARD C++. Et j'ai bien dis STANDARD, or la libpthread, n'est pas un standard C++ c'est un standard POSIX qui a été implémenté entre autre pour le C++. Or le standard POSIX nécessite un OS qui supporte ce standard.
Comme vous le savez tous, une arduino n'a pas d'OS, donc pas de POSIX, donc pas de libpthread.
Par contre vous aurez accés aux trucs standard de C++ (pratiquement tout il me semble) et la libC.

Merci pour ces éclaircissements, comme je l'ai dit, je n'ai jamais utilisé arduino. Y'a vraiment la STL c++ dessus ?

Concernant maintenant les threads :
Ce que l'on appelle thread ce sont des parties de code indépendantes, qui peuvent se "préempter" les unes les autres (souvent avec des priorités).
Il n'est pas obligé d'utiliser la libpthread pour creer des threads.

C'est tout à fait ça. D'ailleurs il existe d'autres librairies de threads à ce qu'il me semble.

Sur un microcontroleur comme arduino, il existe des timers que l'on peut utiliser, ou des interruptions externes. Certaines fonctions sont alors appellées à ce moment la uniquement et on peut appeller ça un thread (car ne faisant pas parti d'une boucle et s'executant sur une interruption).

Perso dans l'arduino j'ai un "thread" principale qui tourne dans la loop() qui fait des trucs, et j'ai un autre thread qui se lance toutes les X millisecondes (sur un reveil de timer) et qui s'execute en mettant en pause la loop.

On a donc 2 parties de codes totalement differentes qui s'executent totalement indépendament. Ce sont donc des threads.

2 threads, c'est encore gérable "à la main", mais quand on commence à en avoir plus, ça devient vite un vrai casse-tête de gérer entre autres les interblocages.

Mais ces bibliothèques, on peut les faire soit meme je crois non ? Pas moyen de retranscrir pour arduino ?

Autant réinventer la roue, et il n'est pas certain que l'embarqué d'arduino ait des capacités suffisantes pour en réinventer toutes les formes disponibles ailleurs.

J'aimerai coder en "dur" pour pouvoir fixer moi meme son comportement général, mais aussi lui donner un système d'apprentissage.

Fais toutes les couches en dur, sans apprentissage, puis quand tu aura un programme fonctionnel complet, remplace le codage en dur d'une des couches par de l'apprentissage.

Le problème c'est comment lui faire apprendre, c'est à dire ajouter qqch de nouveau à la structure du programme..
Peut etre en créant des tas de variables et fonctions vièrges, le tout triés par catégories.

Pour faire de l'apprentissage automatique, il te faut une structure rigide de contrôle (exemple A réseau de neurone : une matrice de connexions (synapses) entre différentes cases (neurones) – exemple B algos génétiques : un ensemble des bouts de code élémentaires prédéfinis (des gènes) dans une population d'individus limitée) dans laquelle certaines choses vont évoluer (exemple A : les pondérations des synapses, plus leur poids est fort, plus elle transmettrons l'excitation de leurs neurones en amont à leurs neurones en aval – exemple B : le programme (ou l'adn) de chaque individu, c'est à dire l'ordre dans lequel vont êtres exécutés ces bouts de codes et les structures entre elles (tests, boucles, etc.)).

Dans cette structure rigide définie, ces composants évolutifs vont être "dirigés" alternativement par 2 choses : l'exploration (on change au hasard) et on évalue l'amélioration du résultat, et le renforcement (on reteste ce qui a déjà fonctionné plus tôt, éventuellement avec des modifications minimes, et on évalue l'amélioration du résultat. Dans les 2 cas, il faut évaluer le résultat (donc il faut une fonction d'évaluation, de satisfaction ou quelque chose qui s'y assimile) et en fonction de ce résultat on oriente en retour les prochains renforcements (exemple A : on augmente les poids des synapses utilisées quand le retour est positif – exemple B : on privilégie la reproduction des individus performants).

Ça a ses limites, à savoir : la rigidité de la structure de contrôle, dont on fixe arbitrairement la taille et la forme, la difficulté de doser la part d'exploration par rapport à la part renforcement, et la complexité de la pertinence de la fonction d'évaluation.

Et aussi lui introduire l'oublie :

C'est intégré : (exemple A : avant chaque passage, le poids de chaque synapses est rapproché de zéro de manière infime, afin que la somme des poids des synapses soit constante après altération des poids – exemple B : le nombre d'individus étant constant, pour créer de nouveaux ADN, il faut se défaire d'anciens, les moins efficaces). Il ne peut pas y avoir "apprentissage" sans une forme d'"oubli". Après, si tu parles d'oubli volontaire de solutions efficaces, pour introduire une propension à l'erreur/créativité, c'est un autre problème bien plus complexe encore. Je te déconseille de t'y arrêter pour l'instant...

Pour le partage de taches j'en ai aucune idée.
Je vais déja remplacer mes "delay" par le système similaire qu'on retrouve dans "BlinkWithoutDelay" dans les exemple sur le logiciel; apparement c'est pour éviter que le programme attende la fin du delay pour lire les lignes suivantes, non ??
Sinon je n'ai pas d'autre piste.

Et que fait le programme selon toi en attendant ? C'est exactement ça (le principe, hein, je ne sais pas quel langage tu utilise). Il laisse alors la main à d'autres processus (ou threads). Ceux du programme s'il en existe, sinon ceux de l'OS.
Chaque thread est indépendant en terme d'exécution des autres (ils s'exécutent en parallèle – c'est à dire un pas chez l'un, puis un pas chez l'autre, puis un pas le suivant, etc – mais comme leur contexte est chargé de manière invisible par l'ordi, pour toi, tu a l'impression que chacun fait ce qu'il veut de son coté, comme si tu avais plusieurs programmes qui tournent en même temps). Après, c'est à toi de gérer leurs interactions et de t'assurer que deux threads différents ne vont pas s'empêcher mutuellement de travailler ou se corrompre (imagine 2 personnes différentes écrivant le même poème, il ne faut pas que l'un modifie la fin de la première rime en même temps que l'autre écris la rime qui correspond, ça risque de poser problème...).

Au début de ton programme, tu as intérêt à créer un thread pas couche avec la structure qui te permet de les contrôler tous. Après, il te reste à faire un "programme indépendant" pour chaque couche. (Et à bien penser à éviter les interblocages et à fermer tes threads/process quand tu termine l'exécution.)

Et pour la communication entre les couches, pourquoi pas la faire avec des variables :
La couche 1 inscrit tel valeur dans la variable V
La couche 2 lit a valeur de V, et traite l'info

C'est exactement ça. Mais utilise des structures plus complexes que les variables simples, car il faudra à un moment définir quelles sont les variables partagées et entre certaines couches elles seront symboliques (leur sens fera partie de la variable elle-même). Et fait attention à bien définir de manière visible ET respecter les ensembles de variables en fonction des couches qui ont autorité pour y écrire ou y lire.

miq75, je programme avec le langage d'arduino. Par contre pour l'histoire du multitreads je vois pas du tout comment faire^^

voilà un lien pour les threads, en c (donc qui devrait à priori être accessible avec arduino qui est basé dessus ?) : http://www.siteduzero.com/tutoriel-3-3291-les-threads-et-les-mutex.html

Sinon comme le dit Black Templar, directement en c++ ce sera plus facile...

On pourrait faire aussi des petites fonctions intermédiaires, qui rassembleraient plusieurs informations vennant de différents capteurs, et qui les traiteraient pour justement en ressortir une donné symbolique ? Ca permetterait de ne pas surcharger les couches de lignes de codes.

ben, oui, c'est même à priori avec ça que tu fera la couche 1.

Selon toi quels éléments manqueraient au langage arduino pour etre aussi efficace que le c++ ?

Dans un langage de programmation, tu a 2 composantes : la syntaxe, c'est la structure qui décrit la programmation (les if/then/else, les boucles, comment définir une variable, etc...) et les bibliothèques, qui sont des collections de fonctions qui représentent l'ensemble de tout ce qui a été écrit génériquement pour faciliter la tache du programmeur avec des outils de haut niveau.

D'après ce que j'ai aperçu du langage arduino, c'est une surcouche de contrôle spécifique aux composants qui s'appuie donc sur la composante syntaxique du c. En gros : le langage arduino, c'est du c minimaliste + une bibliothèque pour les composants arduino. Et c'est tout. Tu n'auras pas les bibliothèques de threads, par exemple.

Le langage c++, c'est au contraire l'accès à tout ce qu'on peut faire en informatique, y compris le plus complexe. Mais pour cela il faudra les bibliothèques correspondantes à tes besoins, donc du c/c++ embarqué sur un linux.

Ce qu'il manque à arduino, c'est donc toutes les bibliothèques standard du c/c++.

miq75, d'aprés ton lien c'est la fonction "void" qui introduit le tread ? Si c'est ça alors c'est ce que je fais déja. Il faut juste que j'évite d'utiliser "delay()" pour éviter le ralentissement de la lecture des treads:
par exemple si je veux faire clignoter 2 leds à des fréquances différentes, si j'utilise "delay()" le programme va faire clignoter les leds l'une aprés l'autre et non simultanément.

Non, c'est "pthread_create" qui introduit le thread (qui sépare l'execution en deux branches, c'est à dire la ligne suivante de code d'un coté, et le contenu de la fonction passé en argument de l'autre coté). Le "void* ma_fonction(void* data);" est la fonction qui décrit ce que fera le thread, et son nom, c'est "ma_fonction". "void*", c'est le type de retour de la fonction du thread (en gros un pointeur sur un type indéfini).

En gros, tu écrit une fonction de la forme
void* couche_numero_x(void* data);
qui va contenir une boucle infinie : le traitement de ta couche.
et tu fais un appel à
pthread_create(&thread, NULL, couche_numero_x, (void*)&valeur);
par thread (= couches) que tu veut gérer.


De toute façon, si tu veut mettre un semblant "d'intelligence", c'est à dire des algos te permettant l'apprentissage, tu aura besoin de passer par c ou c++, alors autant l'apprendre tout de suite.

ben... après, ça dépends ce qu'il entends par "intelligence", hein :Þ

Pour moi l'intelligence artificielle c'est essayer de trouver tous les moyens pour dégrader la supériorité calculatoire de la machine.
La machine n'a besoin de rien, tous lui est fourni (l'electricité, la matière...), elle s'auto-organise de manière plus ou moins stable avec différents systèmes d'exploitations; Elle peut sans problème réciter toutes les tables de multiplication 400000 fois en une seconde et le tout sans faire une seule erreur... Elle peut être connectée au monde entier par une vieille prise téléphonique.
Et en plus de ça, elle ne craint pas la mort, n'en a pas conscience, son esprit est stocké dans un disque dur qui peut être mis dans une autre machine et même copié sur un DVD.
Le rêve...

Bon beh un humain c'est bien moins que ça, c'est tout pourri un humain. Et ça te fais une tour Eiffel, une Joconde, une Venus de Milo, la macarena, ca a toujours besoin de quelquechose, ca veut devenir quelqu'un quite à en tuer d'autres. Il faut donc ajouter à la machine des modules afin qu'elle devienne dépendante, qu'elle fasse une erreur de calcul toutes les 4 secondes, qu'elle imprime en 4 mois un tableau d'une beauté incomparable, qu'elle puisse se débrouiller dans n'importe qu'elle situation.

Si on veut faire bouger la machine, la rendre "intelligente", il faut la rendre débile.

Tu me donne envie de faire un parrallèle avec la découpe du lapin.
Quand un boucher (intelligent) découpe un lapin, il plante son couteau dans les articulation pour séparer les morceaux, il ne brise pas les os, il les sépare.
Quand une machine (pas intelligente) découpe un lapin, elle donne des grands coups de hachoir automatisés. Elle ne sépare pas les os, elle les brise.

Résultats :
-La machine découpe des centaines de lapins pendant que le boucher en découpe un seul.
-La personne qui mange le lapin du boucher mange un bon lapin, même si c'est chiant, tout ces petits os, ça reste un bon lapin.
-La personne qui mange un lapin de la machine mange aussi un bon lapin, mais ce qu'elle retiendra de l'expérience, c'est qu'elle se blesse avec les fragments d'os coupants dus à la découpe automatisée du lapin.

Tout ça pour dire que c'est bien beau qu'une machine soit capable de merveilles de rigueur dont l'intelligence humaine n'est pas capable, mais au final, justement, l'intelligence humaine n'en est pas capable. Donc pour interfacer correctement la machine avec l'humain, j'ai tendance à penser qu'il faut que la machine se mette au niveau de l'humain.

Le problème des intelligences purement rationnelles c'est qu'elles ne bougent pas d'elle même. Pour faire tout bien, autant ne rien faire. En effet, une intelligence rationnelle va récupérer des concepts, les associer pour en déduire des relations logiques qui sont consolidées. Seulement, pour acquerir des données, il faut explorer le monde. Qu'est ce qui peut donner du mouvement à une telle intelligence ?

La soif de connaissances ?

La conscience c'est L'IA forte.
Pour l'instant tout les robots sont constitués d'IA faible plus ou moins développé. C'est a dire avec des automatismes
plus ou moins complexe.

Je pense que pour commencer à faire tendre une IA faible vers une IA forte, il faut lui permettre de travailler sur un espace de représentation du monde suffisemment riche pour qu'elle puisse avoir conscience d'elle même, et il faut lui implémenter (ou lui donner une capacité d'auto impléméentation) des mécanismes suffisemment complexes pour qu'elle puisse se les coriger volontairement. Mais cela ne sera pas forcément suffisant (a moins peut être que sa capcité de commettre des erreurs ne découle directement de ces deux composants*)

*: À ce propos : Est ce que les situation provoquées dans une phase d'exploration (qui s'oppose à une phase d'utilisation) lors d'un apprentissage, et qui sont souvent le fruit d'un hasard plus ou moins controlé, peuvent être considérée comme des erreur ? Cela impliquerait que les systèmes d'apprentissage sont capables d'hors et déjà capable d'en commettre...

En fait, la "soif de connaissance" n'est qu'une conséquence positive de son système de pulsion. En réalité, elle est animée par la volonté d'établir des contacts sociaux car il ne saurait y avoir d'intelligence sans évolution sociale.

Il est important de ne pas aborder ce besoin d'engrenger des données comme constituant une source de motivation. Avec cette approche, on fonce droit dans le mur car il est alors impossible de pondérer, ou relativiser si vous préférez, la valeur de tel ou tel savoir.

Le contact social et l'évolution dans un groupe permet de quantifier automatiquement quelle information est importante ou non...

Il vaut donc mieux voir l'IA sous l'angle social plutot que système d'acquisition de donnée

Oui et non, je ne serai pas aussi affirmatif.
Par exemple un robot qui se trouverai parachuté seul dans un territoire hostile à la vie humaine aurai besoin de connaitre son environnement, et donc d'explorer, et ce, même s'il sait qu'il n'aura pas ou peu d'interactions sociales.
Tu ne peut donc pas dire que l'évolution sociale est la clef de l'intelligence dans toutes les circonstances.
Maintenant, je te rejoint sur le fait que c'est un moteur d'action plus intéressant que la simple "soif de connaissances".

Par ailleur, ça me fait penser à un truc : l'intelligence des supercolonies d'insectes. Ils construisents des structures très complexes mais sans avoir connaissance du schéma global. Dans leur cas, je pense qu'on peut dire que leur intelligence est cablée génétiquement, dans des comportements simples (un peu comme le V des oiseaux est en fait la résultante de 2-3 stimuli : un truc du genre "suivre le groupe","ne pas avoir l'autre pile devant soit". À aucun moment l'oiseau n'a conscience de la formation en V.)
Est-ce que la manière dont on cherche ici a définir les composantes de l'IA est compatible avec un tel cablage génétique ? Est-ce que ça veut dire que l'IA forte n'a pas besoin de se connaitre elle même (dans le cas de l'IA distribuée) ?

Il reste a décrire l'IA forte, ce que beaucoup ont deja tenté de faire. Un des critères énoncé est la sociabilité.
Je regrette mais certaines personne dans mon lycée font abstraction de ce point mais elles sont quand meme intelligente, enfin..^^
(une petite parenthèse au type qui a mis la vidéo : on dirait une pub pour une secte, ça fait un peu peur ...)

La sociabilité est un des aspects de l'intelligence, mais n'est ni unique, ni systématiquement nécessaire. L'intelligence est un composé de plusieurs choses. Pour s'en convaincre, il suffit de regarder les test d'intelligence : le premier a sortir mesurait le QI (quotient intellectuel) parce qu'on à pensé (à l'époque) que l'intelligence était une capacité purement logique. Maintenant, on en fait pour tout, le quotient émotionnel, le quotient affectif, le quotient linquistique, etc....
Après, chacun a aussi une vision différente de ce qu'est ou doit être l'intelligence.

Il faut donc ajouter à la machine des modules afin qu'elle devienne dépendante, qu'elle fasse une erreur de calcul toutes les 4 secondes

Pas forcément. Je pense que la simple faculté d'oublier (une mémoire à long terme très peu utilisée -un peu comme un cache vidé - ou au contraire une altération aléatoire de mémoire vive, occasionnellement) et un mécanisme alléatoire de test de validité du résultat et de remise en question du calcul sont suffisants (ou en tout cas, déjà très intéressants à tester afin de mieux comprendre notre 'intelligence').

par contre ils sont , du moins pour l'instant, incapables de faire des découvertes scientifiques.

C'est pas tout a fait vrai, on utilise des automates formels pour faire de la preuve et de la découverte mathématique. Ce dont ils ne sont pas capable de se rendre compte, c'est à quel point leurs découvertes sont intéressantes ou pas.

J'aurais tendance à dire que "l'intelligence" tiends en plusieurs choses :

- être capable de survivre et de progresser (évoluer vers la complexité ?) de manière autonome
- autrement dit d'être capable de déterminer des objectif à différents termes, et de juger lequel on tente d'appliquer à chaque instant, en les équilibrants
- d'être capable d'apprendre, d'essayer, de commettre des erreurs, de s'en rendre compte et de (en en analysant les mécanismes) ne pas les refaire
- d'une manière générale (puisque c'est déjà le cas pour les deux points précédents) d'être capable de s'abstraire d'un niveau de raisonnement et de s'y remettre au besoin. Ça implique une successions de "niveaux" de raisonnement, et d'être capable de se modéliser son propre raisonnement.

Euh, juste un détail : tu n'es pas obligé de poster une nouvelle réponse à chaque citation, hein !

Arf, je ne peut pas éditer pour recoller mon texte (sur d'autres forums, les réponses consécutives du même auteur sont grouppées, je comptais la dessus. Et puis j'ai répondu dans l'ordre dans lequel je me faisais ces remarques, en lisant en diagonale les pages...

Pour répondre à ta remarque sur les découvertes scientifiques, j'étais au courant de ce que tu précises ^^. Ce que je voulais dire, c'était que ces robots sont utilisés comme des outils ultra-perfectionnés, mais qu'ils restent des outils, des "moyens" de découverte, un peu comme lorsque les mathématiciens se sont servis des super-ordinateurs pour résoudre certains problèmes, comme celui de trouver la Nième décimale du nombre Pi ou encore pour trouver un contre-exemple à la conjecture d'Euler..., bref, comme tu l'as dit, eux-mêmes ne se rendent pas compte de ce qu'ils font, ce sont les humains qui analysent ensuite leurs résultats.

Heureusement d'ailleurs...

D'ailleurs je suis très intriguée par le terme "conscience de soi-même", dans ton explication suivante : "pour commencer à faire tendre une IA faible vers une IA forte, il faut lui permettre de travailler sur un espace de représentation du monde suffisamment riche pour qu'elle puisse avoir conscience d'elle même, et il faut lui implémenter (ou lui donner une capacité d'auto implémentation) des mécanismes suffisamment complexes pour qu'elle puisse se les corriger volontairement". N'existe t'il pas déjà des IA capables de s'auto-corriger ?

Oui, elles sont capables de s'auto-corriger, mais ce processus est cablé par le programmeur. C'est une analyse logique du système qu'a fait le programmeur et qui a défini les choses que la machine peut apprendre (la mémoire ou le cablage interne). La machine n'a pas (encore et à ma connaissance) la capacité de sortir de cet espace prédéfini.
L'étape suivante qui arrive, c'est cette capacité de s'adapter selon ses propres règles choisies soit même, et non pas implémentées de l'extérieur. Une capacité qui permettrait de sortir de cet espace prédéfini, quand on le souhaite. Dans l'exemple mathématique, c'est l'humain qui analyse le résultat. Une IA forte devrait ne pas avoir besoin de cet intervenant extérieur, elle devrait analyser son propre raisonnement en modélisant le fait que c'est elle même qui le fait, et donc en ayant entre autres connaissances une représentation d'elle même et de ses capacités. Autrement dit : une conscience de soit.

Bonjour,

Je n'y connait rien en robotique, mais je m'y connait en IA, et plus généralement en langages de programmations.
J'ai un faible pour le langage python (que je trouve extrèmement puissant, polyvalent, extrèmement simple d'utilisation et multiplateformes, tout en étant beaucoup plus léger le mastodonte java) pour ce qui est de la programmation.
Est il aisé de controler un robot avec un code en python (des interfaces python/machine(senseurs/activateurs) existent elles déjà) ?
Des projets de robotique codés en python existent ils déjà ?

Et si les briques unitaires du sens d'un mot abstrait étaient les mots et le sens complet de ces mots une phrase ou un ensemble de phrases ?
On a déjà des briques unitaires pour le sens de certains mots concrets (par exemple la couleur, ce serait entre autres codage RGB, le verbe etre ce serait un codage d'appartenance à ).
On a la logique mathématique comme agrégant...
La "pensée" serait elle alors une modélisation de certains sens, suivant un modèle logique, représentant un arbre sémantique (ou une structure similaire), construit avec des sens choisi au hasard parmis ceux connus ? Aisni que la déduction d'une nouvelle connaissance ou un ajustement de ces connaissances ?

exemple:
"droite" "ensemble de points alignés"
"segment" "ensemble de points alignés"
"point" "intersection de deux droites"

Une recherche de similitudes dans les définitions pourrait donner :

machine : "droite egal segment ?"
humain : "droite etre infini"
humain : "segment etre fini"

-> création de "fini" et "infini", vierges de sens, ajout de ;"infini" dans droite et de ;"fini" dans segment

machine : "fini ?"
humain : "avoir fin"
machine "infini ?"
humain : "non avoir fin"

-> création des champs sens de fini et infini, détection de l'opposition entre les deux (pour peu que le sens de "non" soit connu)

machine : "droite non egal segment"
humain : "oui"

-> ajout de "non egal segment" a droite et de "non egal droite" a segment

machine : "droite egal ensemble de point alignés infinis ?"
humain : "droite egal esemble infini de points alignés"

-> transformation des 2 premières propriétés connues de la droite en une seule, selon la formule donnée par l"humain, rappel de similarité entre droite et segment :

machine : "segment egal ensemble fini de points alignés ?"
humain : "oui"

-> transformation des 2 premières propriétés connues du segment en une seule ...

Alors, ça ressemble à de la "pensée" ?