ProgramE est un moteur d’agent conversationnel AIML open-source utilisant une base de données et dont l’avantage est de pouvoir être joint par protocole XML-RPC.

Pour ceux qui ont un compte sur le site pandorabots.com, vous pouvez retrouver cette interface XML-RPC joignable par adresse formée sur le modèle :

http://www.pandorabots.com/pandora/talk-xml?botid=xxxxxxxxxxxxxxx&input=question envoyée au bot

Avec des réponses de la forme :

<result status=0 botid=xxxxxxxxxxxxxxx custid=xxxxxxxxxxxxxxx>
    <input>question envoyée au bot</input>
    <that>Réponse du bot</that>
</result>

Le site de pandorabots apporte de nombreux autres services et interfaces bien pratiques, mais il se trouve que le débit disponible pour les requêtes vers ce site est très largement utilisé ce qui peut causer des problèmes de disponibilité. C’est ce qui nous a fait chercher une solution alternative à installer sur nos serveurs. Toute une liste est d’ailleurs disponible sur le site extrêmement bien documenté alicebot.org : http://www.alicebot.org/downloads/programs.html

Notre choix s’est vite porté sur programE pour son interface XML-RPC car notre but n’est pas d’utiliser ce moteur avec une interface PHP ou HTML classique, mais plutôt de pouvoir le lier à d’autres programmes et plus particulièrement avec un programme permettant de loguer dans Second Life des avatars reliés à des agents conversationnels : ssmbot (à télécharger ici), dont nous parlerons plus en détails plus loin…

Installation de programE v0.9, modification des sources et patch

Quelques modifications des sources de la version 0.9 pour pouvoir le faire tourner sur mon serveur web : update_programe_05-07-10.patch.

Les principales modifications sont les changements de balises « <? » en « <?php » (qui généraient un grand nombre d’erreurs sur mon serveur) et la gestion des arguments passés dans l’adresse de la page xmlrpcserver.php pour la communication XML-RPC (voir ci-dessous).

Communication XML-RPC

Sur ProgramE patché on peut joindre l’interface XML-RPC de la même manière par adresse de type :

http://monserveurweb/programe/src/xmlrpcserver.php?input=question envoyée au bot&myid=xxxxxx&botname=MyBot

Et les réponses seront de la forme suivante :

<?xml version="1.0" encoding="utf-8"?>
<methodResponse>
<params>
 <param>
  <value>
   <struct>
    <member>
     <name>response</name>
     <value>
      <string>Réponse du bot</string>
     </value>
    </member>
    <member>
     <name>patternsmatched</name>
     <value>
      <array>
       <data>
        <value>
         <string> * Pattern reconnue par le bot * : * : *</string>
        </value>
       </data>
      </array>
     </value>
    </member>
    <member>
     <name>inputs</name>
     <value>
      <array>
       <data>
        <value>
         <string>Ancienne question envoyée au bot : Ancienne question envoyée au bot :
Ancienne question envoyée au bot</string>
        </value>
       </data>
      </array>
     </value>
    </member>
    <member>
     <name>errors</name>
     <value>
      <string/>
     </value>
    </member>
    <member>
     <name>timer</name>
     <value>
      <double>0.007779</double>
     </value>
    </member>
   </struct>
  </value>
 </param>
</params>
</methodResponse>

Pour le projet DEFICELONS, nous avons installé le système de décodeur de Moses pour permettre d’effectuer de la traduction en temps réel anglais > français et français > anglais dans la langue de Henry David Thoreau.

Toute la partie analyse, entrainement et apprentissage a été effectué par François Yvon du LIMSI.

Installation du décodeur Moses

Nous allons donc ici nous intéressé à l’installation sur Debian 5.0 du décodeur Moses. Voici un guide très bien fait : http://www.statmt.org/moses_steps.html

———- SRILM

Télécharger le modèle de langage SRILM : http://www.speech.sri.com/projects/srilm/download.html

Changer la variable SRILM en haut du Makefile pour l’adresse ABSOLUE du dossier.

Si vous avez une machine 64bits, il faut modifier le fichier sbin/machine-type :
else if (`uname -m` == x86_64) then
set MACHINE_TYPE = i686-m64
#set MACHINE_TYPE = i686

Puis compiler :
make World
make test
make cleantest

———- IRSTLM

Télécharger les outils IRSTLM : http://sourceforge.net/projects/irstlm/

Puis compiler :
./configure –prefix=/adresse/absolue/du/dossier/contenant/IRSTLM
make
make install

———- BOOST

Pour lancer Moses en mode serveur et non uniquement en console il faut télécharger BOOST (version 1.35 ou supérieure) : http://www.boost.org/

cd adresse/de/boost_1_43_0
./bootstrap.sh –help

Sélectionnez vos options de configuration et relancer ./bootstrap.sh sans l’option –help.
./bootstrap.sh –prefix=/usr/local/lib/boost

./bjam install

———- XMLRPC-C

Pour lancer Moses en mode serveur il faut également XMLRPC-C. Sous Debian l’installation est très simple :
apt-get install libxmlrpc-c-dev

———- MOSES DECODER

Télécharger : http://sourceforge.net/projects/mosesdecoder/

Puis compiler :
./regenerate-makefiles.sh

pour la version en mode console :
./configure –with-srilm=/Adresse/absolue/srilm  –with-irstlm=/Adresse/absolue/irstlm

pour la version en mode serveur :
./configure –with-srilm=/Adresse/absolue/srilm –with-irstlm=/Adresse/absolue/irstlm –with-boost=/usr/local/lib/boost –enable-threads –with-xmlrpc-c=/usr/bin/xmlrpc-c-config

make -j 4

Lancement du décodeur

Moses en mode console est dans moses-cmd/src

cd /adresse/de/moses/moses-cmd/src/
./moses -f adresse/fichier/de/configuration/moses.weight-reused.ini

Moses en mode deamon est dans web/bin :

cd /adresse/de/moses/web/bin/
./daemon-en-fr.pl 127.0.0.1 8080

Moses en mode serveur est server/mosesserver :

Ne pas oublier avant CHAQUE démarrage de moses d’exporter l’adresse de Boost :
export LD_LIBRARY_PATH=/usr/local/lib/boost/

cd /adresse/de/moses/server/
./mosesserver -f adresse/fichier/de/configuration/moses.weight-reused.ini –server-port 8080 –server-log /var/log/moses.log

On met notre texte.
MARMOTTE = « Texte »

On épure alors le texte de toute ponctuation afin de travailler uniquement sur les mots.
MARMOTTE=StringReplace[MARMOTTE, "."->" "];
MARMOTTE=StringReplace[MARMOTTE, ","->" "];
MARMOTTE=StringReplace[MARMOTTE, "!"->" "];
MARMOTTE=StringReplace[MARMOTTE, "?"->" "];
MARMOTTE=StringReplace[MARMOTTE, "-"->" "];
MARMOTTE=StringReplace[MARMOTTE, ":"->" "];
MARMOTTE=StringReplace[MARMOTTE, ")"->" "];
MARMOTTE=StringReplace[MARMOTTE, "("->" "];
MARMOTTE=StringReplace[MARMOTTE, "'"->" "];
MARMOTTE=StringReplace[MARMOTTE, ";"->" "];
MARMOTTE=StringReplace[MARMOTTE, "/"->" "];

On compte les occurrences des mots dans le corpus
str1=StringToStream[MARMOTTE]
l= ReadList[str1,Word];
InputStream[String,12]
l1=ToLowerCase[l];
lu=Union[l1];
Length[lu];
lsp=Flatten[Map [If[StringTake[#,-1]=== »s »&& Not[MemberQ[lp,#]],{},#]&,lu]];
Length[lsp];
lc=Map[{Count[l1,#],#}&,lsp];(* LENT *)
lcs=Reverse[Sort[lc]];
ListPlot[Transpose[lcs]P1\[RightDoubleBracket],Joined->True,PlotRange->All]
ListPlot[Transpose[lcs]P1\[RightDoubleBracket],Joined->True,PlotRange->{Automatic,{0,100}}]
TableForm[Take[Partition[lcs,6],50],TableDepth-> 2,TableSpacing->{0,0}]
{
{{187,de}, {149,et}, {120,la}, {97,à}, {93,l}, {89,que}},
{{80,un}, {74,est}, {67,le}, {65,d}, {64,une}, {59,je}},
{{58,il}, {51,qui}, {50,qu}, {50,ne}, {47,en}, {46,n}},
{{37,ce}, {32,pour}, {30,ou}, {29,j}, {28,comme}, {25,se}},
{{24,si}, {24,peut}, {24,même}, {24,être}, {24,a}, {23,du}},
{{23,avec}, {21,homme}, {21,c}, {19,bien}, {18,vie}, {18,son}},
{{17,sont}, {17,sa}, {17,par}, {17,ai}, {16,au}, {15,on}},
{{15,mon}, {14,—}, {14,y}, {14,ma}, {13,lui}, {13,était}},
{{13,aussi}, {12,elle}, {12,cette}, {11,quand}, {11,notre}, {10,peu}},
{{10,pêche}, {10,nourriture}, {10,chaque}, {10,celui}, {9,soit}, {9,pureté}},
{{9,ni}, {9,nature}, {9,me}, {9,ceux}, {8,tout}, {8,sur}},
{{8,manger}, {8,leur}, {8,chasse}, {8,aux}, {7,toute}, {7,sensualité}},
{{7,pourtant}, {7,m}, {7,fait}, {7,été}, {7,encore}, {7,car}},
{{7,avoir}, {6,sauvage}, {6,personne}, {6,ont}, {6,là}, {6,jour}},
{{6,humanité}, {6,fusil}, {6,étang}, {6,chasseur}, {6,ça}, {6,beaucoup}},
{{6,autre}, {6,animale}, {5,vivre}, {5,trop}, {5,sujet}, {5,propre}},
{{5,pêcheur}, {5,parce}, {5,origine}, {5,non}, {5,moi}, {5,importe}},
{{5,imagination}, {5,eux}, {5,esprit}, {5,davantage}, {5,cela}, {5,appétit}},
{{4,savoir}, {4,rien}, {4,quelque}, {4,quelle}, {4,quel}, {4,pratique}},
{{4,parler}, {4,outre}, {4,où}, {4,objection}, {4,mesure}, {4,loin}},
{{4,lequel}, {4,jusqu}, {4,honte}, {4,génie}, {4,fût}, {4,faire}},
{{4,façon}, {4,étaient}, {4,entre}, {4,doit}, {4,dit}, {4,dire}},
{{4,deux}, {4,cause}, {4,animaux}, {4,aller}, {4,ainsi}, {3,vraiment}},
{{3,voir}, {3,véritable}, {3,veda}, {3,travaux}, {3,travail}, {3,tenté}},
{{3,tel}, {3,tant}, {3,stade}, {3,souvent}, {3,soir}, {3,seulement}},
{{3,santé}, {3,sage}, {3,rendre}, {3,raison}, {3,quoi}, {3,quelqu}},
{{3,plupart}, {3,peux}, {3,pendant}, {3,pêcher}, {3,part}, {3,opinion}},
{{3,occupation}, {3,musique}, {3,morceau}, {3,matin}, {3,mangé}, {3,lorsque}},
{{3,larve}, {3,laquelle}, {3,journée}, {3,jeune}, {3,instinct}, {3,impureté}},
{{3,ici}, {3,humaine}, {3,humain}, {3,grossier}, {3,expérience}, {3,existence}},
{{3,état}, {3,estime}, {3,doute}, {3,dont}, {3,difficile}, {3,dieu}},
{{3,déjà}, {3,comment}, {3,ciel}, {3,chose}, {3,chez}, {3,cet}},
{{3,cependant}, {3,bon}, {3,boire}, {3,autrement}, {3,autant}, {3,aucun}},
{{3,assez}, {3,animal}, {3,angleterre}, {2,»}, {2,«}, {2,vrai}},
{{2,voyageur}, {2,voulez}, {2,votre}, {2,voit}, {2,voie}, {2,vertu}},
{{2,vaincre}, {2,va}, {2,trouvé}, {2,tour}, {2,tiré}, {2,thé}},
{{2,table}, {2,surprenait}, {2,sûrement}, {2,sûr}, {2,suite}, {2,suggéraient}},
{{2,spirituelle}, {2,soient}, {2,simplement}, {2,seul}, {2,sert}, {2,sérieux}},
{{2,serait}, {2,sera}, {2,sentiment}, {2,sensibilité}, {2,semblait}, {2,saveur}},
{{2,sagesse}, {2,religieux}, {2,race}, {2,quoique}, {2,puisse}, {2,presque}},
{{2,présent}, {2,préfère}, {2,pourrait}, {2,pourquoi}, {2,possible}, {2,poisson}},
{{2,pitié}, {2,pense}, {2,pasteur}, {2,passe}, {2,partie}, {2,pareil}},
{{2,papillon}, {2,pain}, {2,ornithologie}, {2,ordonnée}, {2,ordinaire}, {2,oiseaux}},
{{2,observer}, {2,obligé}, {2,nuit}, {2,nouvelle}, {2,nouveaux}, {2,nourrir}},
{{2,nourri}, {2,noble}, {2,monde}, {2,mangeur}, {2,mange}, {2,maintenant}},
{{2,lorsqu}, {2,longue}, {2,législature}, {2,laisse}, {2,jouer}, {2,jeux}},
{{2,jeunesse}, {2,inspire}, {2,insignifiant}, {2,inférieure}, {2,indifférent}, {2,hindou}},
{{2,harpe}, {2,goût}, {2,genre}, {2,gelée}, {2,garçon}, {2,fut}},
{{2,fraîche}, {2,font}, {2,fonction}, {2,flûte}, {2,fin}, {2,faut}},
{{2,étrange}, {2,étonnant}, {2,étant}, {2,entière}, {2,entend}, {2,enfin}}
}

On obtient alors les 50 mots les plus utilisés dans notre corpus.

On peut également remplacer aisément une chaîne de caractères (pour supprimer on peut remplacer par un espace)
PERDU1=StringReplace[MARMOTTE," motàremplacer " -> "motremplaçant"];

« L’Homme peut-il penser comme une machine ? »

Les prémices de ce projet ont été présentés sous plusieurs formes. Tout d’abord en workshop qui s’est déroulé du 4 au 10 Juin 2010 au théâtre Paris-Villette puis par la suite présenté en tant qu’installation au Fresnoy du 24 au 26 Juin 2010.

Le défit technologique était ici de pouvoir instaurer un dialogue Homme/Machine et même Machine/Machine en respectant les écrits de H.D Thoreau. Cette thématique a donc soulevé de nombreuses problématiques techniques telles que :

• La notion d’agents conversationnels
• La traduction automatique
• La synthèse vocale
• Les mondes virtuels
• Les avatars
• La transmission de données temps réel
• Le stockage / « parsage » d’un corpus de textes

En tant qu’ingénieurs x-réseaux, nous nous sommes particulièrement intéressés au développement d’un système d’agents conversationnels temps réel, capables de créer et d’entretenir un dialogue littéraire composé des écrits de l’écrivain Américain. Trois phases ont pu être dissociées lors de la réalisation de ce projet :

- La première étant le traitement du corpus de base. En effet, afin de nourrir et d’instruire nos agents conversationnels, il a fallu trouver un moyen de stocker, d’ordonner et de réutiliser le texte de Walden.

Technologies utilisées : Java, MySQL, expressions régulières…

- Le deuxième temps de développement a eu pour but de rendre accessible et compréhensible par les agents conversationnels le corpus sélectionné.

Technologies utilisées : Java, MySQL, AIML…

- Enfin la dernière étape a été la connexion réciproque entre les acteurs et/ou les systèmes temps réel avec le monde virtuel (Second Life).

Technologies utilisées : Java, C#, PHP/MySQL, OSC protocol,  Program E, librairie libopenmetaverse, Seconde Life…

Cet article est le premier d’une série d’explications et de solutions techniques qui s’inscrit dans notre désir de partage didactique de connaissances. Les articles suivant s’accompagneront de schémas et d’extraits de code qui nous ont permis de finaliser ce projet artistique.

Algo servant d’exemple : bouclelistedelistealté

Importer dans mathematica le texte sur lequel on va travailler. Il est importé sous forme de listes de liste. Chaque sous liste correspond à une chaine de caractères s’arrétant à un passage à la ligne.
MARMOTTE = ReadList["C:/Users/marc/marmottetaguée.txt", String, RecordSeparators ->{}]; {Length[MARMOTTE], Length[Union[MARMOTTE]]}

Chaque phrase doit être taguée, pour cela j’ai créé une liste de liste comprenant des numéros correspondants aux TAGS.
TAGSLIST[[i]] va correspondre aux TAGS de la i ème Phrase (ou chaîne de caractères définies avec les passages à la ligne) du texte.

Algorithme

Clear[NEWLIST]
Clear[RAND]
Clear[c]

On remet la mémoire à 0.
x=1;
b=Ceiling[Random[]*196];
NEWLIST=Table[1,{i,50},{j,2,1}];
c=Table[0,{i,50},{j,1,5}];

Création de 2 listes de listes.

1 liste pour connaître les TAGS de chaque phrase analysée (la liste « c »). Liste de listes comprenant 50 fois la liste {0,0,0,0,0}

1 liste pour répertorier toutes les phrases pouvant répondre à la phrase analysées (liste « NEWLIST »). Liste de 50 listes vides.
RAND=Table[0,{i,50}];

On prend une phrase aléatoire du corpus.
If [MemberQ[TAGSLIST[[b]],1]==True,c[[1]][[1]]=Round[1.49*Random[]],c[[1]][[1]]=Round[0.7*Random[]]];
If [MemberQ[TAGSLIST[[b]],2]==True,c[[1]][[2]]=Round[1.49*Random[]],c[[1]][[1]]=Round[0.7*Random[]]];
If [MemberQ[TAGSLIST[[b]],3]==True,c[[1]][[3]]=Round[1.49*Random[]],c[[1]][[1]]=Round[0.7*Random[]]];
If [MemberQ[TAGSLIST[[b]],4]==True,c[[1]][[4]]=Round[1.49*Random[]],c[[1]
][[1]]=Round[0.7*Random[]]];

Si la phrase sélectionnée (MARMOTTE[[b]]) a le TAG « 1″ alors le premier membre de c[[1]] prend la valeur « 1″ => c[(1]]={1,0,0,0,0}.

On fait le même travail pour chaque TAG.

Une altération est ajoutée dans ce code. Une phrase n’ayant pas initialement de TAG put se voir attribué la présence d’un TAG mais aussi une phrase ayant un TAG peut être analysée comme une phrase ne l’ayant pas.
If [MemberQ[TAGSLIST[[b]],5]==True,c[[1]][[5]]=Round[1.49*Random[]],c[[1]][[1]]=Round[0.7*Random[]]];
For [i=0,i<5,i++
If[c[[1]][[i]]==1,
For[j=0,j<196,j++
If [MemberQ[TAGSLIST[[j]],i]==True, NEWLIST[[1]]=Append [NEWLIST[[1]],j]]
]];
]

On rempli maintenant toutes les phrases pouvant répondre à la phrase d’entrée analysée.

On ajoute dans NEWLIST[[1]] toutes les phrase ayant en commun au moins un TAG avec la phrase analysée. Sachant que si une phrase a plusieurs TAGS en commun avec la phrase analysée alors elle apparaitra autant de fois dans la liste.
If [c[[1]]=={0,0,0,0,0}, RAND[[1]]=Ceiling[Random[]*196],
RAND[[1]]=NEWLIST[[1]][[Ceiling[Random[]*Length[NEWLIST[[1]]]+1]]]];
Print["\n", x++,": "<>MARMOTTE[[b]], »\n », »\n », x++, »:  » MARMOTTE[[RAND[[1]]]]]

Si C[[1]] est égal à {0,0,0,0,0} alors la liste NEWLIST[[1]] est vide, on prend alors une phrase aléatoire dans le texte. Sinon on prend une phrase de façon aléatoire dans NEWLIST[[1]].

On print ensuite cette phrase qui sera la prochaine phrase analysée afin de créer une conversation.
For[m=1,m<50,m++
If[MemberQ[TAGSLIST[[RAND[[m-1]]]],1]==True,c[[m]][[1]]=Round[1.49*Random[]],c[[1]][[1]]=Round[0.7*Random[]]];
If[MemberQ[TAGSLIST[[RAND[[m-1]]]],2]==True,c[[m]][[2]]=Round[1.49*Random[]],c[[1]][[1]]=Round[0.7*Random[]]];
If[MemberQ[TAGSLIST[[RAND[[m-1]]]],3]==True,c[[m]][[3]]=Round[1.49*Random[]],c[[1]][[1]]=Round[0.7*Random[]]];
If[MemberQ[TAGSLIST[[RAND[[m-1]]]],4]==True,c[[m]][[4]]=Round[1.49*Random[]],c[[1]][[1]]=Round[0.7*Random[]]];
If[MemberQ[TAGSLIST[[RAND[[m-1]]]],5]==True,c[[m]][[5]]=Round[1.49*Random[]],c[[1]][[1]]=Round[0.7*Random[]]];
For[i=0,i<5,i++
If[c[[m]][[i]]==1,
For[j=0,j<196,j++
If[MemberQ[TAGSLIST[[j]],i]==True,NEWLIST[[m]]=AppendTo[NEWLIST[[m]],j]]
]];
]
If[c[[m]]=={0,0,0,0,0},RAND[[m]]=Ceiling[Random[]*196+1],
RAND[[m]]=NEWLIST[[m]][[Ceiling[Random[]*Length[NEWLIST[[m]]]+1]]]];
Print["\n",x++,": "<>MARMOTTE[[RAND[[m]]]]]
]

Boucle de ce qui a été fait précédemment afin d’avoir une conversation de plus de 2 occurrences.
Print[c]
Print[TAGSLIST[[b]]]
Print[TAGSLIST[[RAND]]]

Vérifications afin de connaître quelles sont les modifications dues à la perte d’information : les mauvaises transmissions.

Tous les autres algorithmes sur les TAGS fonctionnent de la même manière, avec ou sans altération. La seule chose qui change vraiment est que la présence du TAG « 1″ ne rempli pas forcément la case « 1  » de la sous liste de c (TAGS tournants, oppositions …).

Algorithme mathematica recherchant les mots.

Algo servant d’exemple : nouvelalgosanso

On charge le texte comme précédelent:
MARMOTTE = ReadList["C:/Users/marc/marmottetaguée.txt", String, RecordSeparators ->{}]; {Length[MARMOTTE], Length[Union[MARMOTTE]]};

On analyse toutes les phrase et on les TAGS en fonction de la présence ou non de la chaine de caractères entre « _ ». Equivalent du TAGLIST précédent mais fait ici de manière automatique.
TEST=Table[0,{i,196},{j,16}];
For[i=0,i<196,i++
If [StringFreeQ[MARMOTTE[[i]], »homme »]==False, TEST[[i]][[1]]=1]
]
For[i=0,i<196,i++
If [StringFreeQ[MARMOTTE[[i]], » vie « ]==False, TEST[[i]][[2]]=1]
]
For[i=0,i<196,i++
If [StringFreeQ[MARMOTTE[[i]], »nourriture »]==False, TEST[[i]][[3]]=1]
]
For[i=0,i<196,i++
If [StringFreeQ[MARMOTTE[[i]], »pêche »]==False, TEST[[i]][[4]]=1]
]
For[i=0,i<196,i++
If [StringFreeQ[MARMOTTE[[i]], »nature »]==False, TEST[[i]][[5]]=1]
]
For[i=0,i<196,i++
If [StringFreeQ[MARMOTTE[[i]], »pureté »]==False, TEST[[i]][[6]]=1]
]
For[i=0,i<196,i++
If [StringFreeQ[MARMOTTE[[i]], »manger »]==False, TEST[[i]][[7]]=1]
]
For[i=0,i<196,i++
If [StringFreeQ[MARMOTTE[[i]], »chasse »]==False, TEST[[i]][[8]]=1]
]
For[i=0,i<196,i++
If [StringFreeQ[MARMOTTE[[i]], »sensualité »]==False, TEST[[i]][[9]]=1]
]
For[i=0,i<196,i++
If [StringFreeQ[MARMOTTE[[i]], »huma »]==False, TEST[[i]][[10]]=1]
]
TEST
TEST2=Flatten[TEST]

Une simplification pour l’algorithme.

Algorithme

Clear[NEWLIST]
Clear[c]
Clear[RAND]
b=Ceiling[Random[]*196];

On prend une phrase aléatoire du texte.
x=1;
NEWLIST=Table[0,{i,1,50},{j,2,1}];
Print[x++,": "MARMOTTE[[b]]]
TEST[[b]]
For[i=0,i<10,i++
(*Print[i]*)
For[j=0,j<196,j++
For[i=0,i<10,i++
If[TEST2[[10*(b-1)+i]]==1 && TEST[[j]][[i]]==1,NEWLIST[[1]]=Append[NEWLIST[[1]],j]]
]
]
]

On rempli toutes les phrases pouvant répondre à la phrase d’entrée analysée. Ici, ce sont les phrases contenant un des mots recherchés (que contient la phrase analysée).

On ajoute dans NEWLIST[[1]] toutes les phrase ayant en commun au moins un mot recherché avec la phrase analysée. Sachant que si une phrase a plusieurs de ces mots en commun avec la phrase analysée alors elle apparaitra autant de fois dans la liste.
If[TEST[[b]]=={0,0,0,0,0,0,0,0,0,0},c=Ceiling[Random[]*196],c=NEWLIST[[1]][[Ceiling[Random[]*Length[NEWLIST[[1]]]]]]];

Si la phrase analysée n’a aucun mot recherché, on répond une phrase aléatoirement. Sinon on prend une des phrase de manière aléatoire dans NEWLIST[[1]].
Print[x++, ": ", MARMOTTE[[c]]]
Print[TEST[[c]]]
For[m=1,m<50,m++
For[j=0,j<196,j++
For[i=0,i<10,i++
If[TEST2[[10*(c-1)+i]]==1 && TEST[[j]][[i]]==1,NEWLIST[[m]]=Append[NEWLIST[[m]],j]]
]
]
If[TEST[[c]]=={0,0,0,0,0,0,0,0,0,0},c=Ceiling[Random[]*196],c=NEWLIST[[m]][[Ceiling[Random[]*Length[NEWLIST[[m]]]]]]];
Print[x++,": ",MARMOTTE[[c]]]
Print[TEST[[c]]]
]

On fait alors une boucle.

Pour plus d’informations, télécharger les cours de Mathematica sur le site : http://www.limsi.fr/~jps/

Mathematica est un logiciel :
- De traitement symbolique
- De traitement numérique
- De visualisation
- D’édition de tutoriels
- De programmation

Il a été utilisé dans notre projet en traitement symbolique (analyse des mots contenus dans le corpus), en logiciel de programmation (pour les algorithmes).

Fonctionnement

image provenant du cours de Jean Paul Sansonnet mathintro.3nov08.nb disponible sur le site donné initialement.

Le rôle de Mathematica dans notre projet

L’utilisation principale de Mathematica dans le projet DEFICELONS est de faire un travail sur l’intelligence artificielle de bots / agents conversationnels afin de construire des discussions sensées entre bots, basées uniquement sur le corpus des « Lois supérieures » et/ou de tout le texte de « Walden ou la vie dans les bois » de Thoreau. Nous avons ainsi pu obtenir des partitions de conversations entre bots comme apport d’exemples dramaturgiques concrets.

Pour cela de nombreux algorithmes ont été codés afin de savoir lesquels seraient les plus intéressants d’un point de vue théâtral. Ces algorithmes ont donnés lieux à de nombreuses partitions. Ces partitions étant toujours différentes même en utilisant le même algorithme, ce qui montre bien la construction de la réponse et du dialogue.

Ces partitions ont pour but de voir ce qui est possible, de voir quels types de réponses peut donner la machine et donc de mieux comprendre son fonctionnement. Le grand nombre de partitions et d’algorithmes permet aussi de savoir quels algorithmes sont susceptibles de donner quels types de partitions et quelles partitions sont vraiment intéressantes.

De plus, Mathematica peut modifier le texte. Un des algorithmes travaille sur le remplacement des mots les plus fréquents par un unique mot. Cela permet donc d’altérer le texte (voir Testalgo7.nb et algoanthropophagie.pdf).

Deux problèmes se sont posés avec Mathematica:

- Le premier est l’absence de temps réel. On ne peut lui envoyer des données qu’il analyserait puis renverrait une réponse. Même si le calcul peut être rapide il n’y a pas de lien (tout du moins aucun trouvé ni utilisé) entre l’extérieur de Mathematica et Mathematica lui-même. C’est pour cela que Mathematica n’a servi qu’à faire des partitions en amont et non, comme le fait par exemple programE, des réponses en direct.

- Le second problème est le fait que Mathematica soit restrictif. Même si on peut parler de construction de réponse, ces réponses sont toujours constituées des mêmes briques, immuables : les sous listes. Concrètement la seule réponse que peut renvoyer le bot est une phrase étant déjà dans le corpus. Cela diminue donc énormément les possibilités. Ce n’est pas une réponse « à la Thoreau » mais une réponse « de Thoreau ». De plus, pour les « algorithmes des TAGS » il faut obligatoirement, en entrée, une phrase du corpus.

Pour notre projet, nous avons du créer des dictionnaires aiml tournant sur le moteur d’agents conversationnels programE. Le problème est que certaine subtilité des programmes Mathematica n’ont pu être transmises par dictionnaires aiml notamment tous ce qui a relation avec les altérations de textes, les problèmes de transmissions…