Ajouter une méthode simple à un projet Smag0

Nous avons tenté d'expliquer dans l'article http://smag0.blogspot.fr/2015/06/comment-creer-une-methode-pour-smag0-la.html comment créer une méthode, en nous attaquant à la méthode Diamond. Mais cette méthode est complexe, et longue à mettre en place, on verra ça plus tard.

N'allons pas trop vite en besogne, procédons par ordre. Pour l'instant nous avons la possibilité d'enregistrer les projets ou les instructions que l'on veut envoyer à notre maison, via l'appli Coolitude4, ou via la page des projets, nous avons la possibilité d'ajouter des commentaires sur les projets proposés, et d'extraire de ces projets les termes importants, de les enregistrer au format RDF. Si RDF ne vous dit rien, jetez un petit coup d'oeil sur https://fr.wikipedia.org/wiki/Resource_Description_Framework pour que ce soit plus clair.
(NB : les liens mentionnés sont susceptibles de changer, merci de me le signaler, si vous n'y trouvez plus rien).

Une fois que l'on a notre projet, ou notre requête envers notre maison (voir ASACURQRSC ), 
le système doit posséder des méthodes pour analyser, interpréter, exécuter les instructions.
Partons donc d'un truc tout simple, par exemple... il est 20h36, c'est l'heure de manger, je voudrais manger des pâtes, c'est mon projet, ça devient une requête envers le système qui serait peut-être un jour capable de me faire cuire des pâtes sans me répondre " va te faire cuire un œuf".
Pour que le système puisse y parvenir, il va avoir besoin d'une méthode, comme nous quand on va sur http://www.marmiton.org ... mais en attendant qu'il aille y chercher des recettes complexes, tentons d'établir une méthode simple pour transmettre au système la méthode pour cuire des pâtes.

Primo : c'est quoi la méthode pour faire cuire des pâtes ??
source  : Farfalle - Barilla
 (je dois être le seul mec de tout l'internet à prendre mon code source sur les paquets de pâtes Barilla ;-%)

Modalité de cuisson pour 100g de pâtes :
1 litre d'eau
7g de sel

Faire bouillir l'eau et ajouter le sel.
Verser les pâtes et remuer de temps en temps.
Temps de cuisson 10 min.
Egoutter les pâtes.

En décomposant par étape, en gros, ça ferait :
1. Faire bouillir l'eau
2. Ajouter le sel
3. Verser les pâtes
4. Remuer de temps en temps (pendant 10 minutes )
5 Egoutter les pâtes

Le but étant de créer une méthode exploitable, enregistrable, partageable, modifiable, n'ayant pas trouvé mieux que RDF pour décrire, on va tenter de se le faire avec des triplets, comme ça  :
(voir aussi http://www.w3.org/2001/sw/BestPractices/OEP/SimplePartWhole/)

ici, on va utiliser la propriété rdf:type pour dire que CuireDesPâtes est_une Methode, ou que FairteBouillirEau est_une Etape...

{CuireDesPâtes  rdf:type  Methode}
{FaireBouillirEau rdf:type Etape}
{AjouterSel rdf:type Etape}
{VerserPâtes rdf:type Etape}
{Remuer rdf:type Etape}
/* avoir comment faire le de temps en temps, et le attendre 10 mins... faire les deux actions en parrallèle ??? temporiser ??*/
{EgoutterPâtes rdf:type Etape }

Voilà nos 5 étapes.

Ensuite, pour dire que la méthode CuireDesPâtes est composée de plusieurs étapes nommées FaireBouillirEau, AjouterSel..., on utilisera dc:hasPart, ce qui donnera

{CuireDesPâtes dc:hasPart FaireBouillirEau }
{CuireDesPâtes dc:hasPart AjouterSel
{CuireDesPâtes dc:hasPart VerserPâtes
{CuireDesPâtes dc:hasPart Remuer
{CuireDesPâtes dc:hasPart Attendre10Min } //encore à définir
{CuireDesPâtes dc:hasPart EgoutterPâtes }


on pourra compléter de la manière suivante en utilisant rdf:first pour dire que FaireBouillirEau est la première étape de la méthode CuireDesPâtes.

{CuireDesPâtes rdf:first FaireBouillirEau }

A ce stade, on serait tenter d'utiliser les Collections RDF : https://code.google.com/p/collections-ontology/wiki/RDFContainersAndCollections
mais ceci ne conviendrait pas, on créerait une Sequence avec rdf:Seq, mais on serait obligé de numéroter les étapes, alors que nous voulons quelque chose de souple. Ainsi, si j'ai envie de me créer ma propre méthode CuireDesPâtes2, et que moi, quand je fais des pâtes, j'ai l'habitude de mettre un couvercle, pour que la température de l'eau augmente plus vite ( ce qui n'est pas recommandé par Barilla, cela dit en passant... que ce soit clair entre vous et moi !). Bon admettons que l'on veuille rajouter une étape comme MettreCouvercle... Si on numérote les étapes avec les  propriétés préconisées rdf:_1, rdf:_2..., on sera embêté lors de l'insertion, il faudra renommer toute la suite, de même si on veut supprimer une étape. On va plutôt utiliser une propriété qui nous dira le "suivant" de FaireBouillirEau est AjouterSel.  Cette propriété "suivant" ou "next" (en anglais) ne semble pas avoir été prévu dans les vocabulaires rdf ou rdfs... Comment faire ...??? là se pose la question de tout développeur normalement constitué, qui s'est un peu penché sur RDF, et la notion de réutilisation des vocabulaires. Dois-je créer ma propre propriété avec mon propre prefix, un truc du style "smag:next"???

Que nenni, car c'est là qu'intervient notre ami Lovokfnorg ou plutôt http://lov.okfn.org/... Qui c'est celui-là ? un moteur de recherche de vocabulaires RDF... et en lui demandant s'il connait quelque chose qui correspondrait à notre "next" tant désiré, il nous répond :

• xhv:next(xhv)0.780
  

  7 occurrences in 5 LOD datasets

  http://www.w3.org/1999/xhtml/vocab#next

  http://www.w3.org/ns/rdfa#term next

  rdfs:comment next refers to the next resource (after the

  localName next

  http://www.w3.org/ns/rdfa#uri http://www.w3.org/1999/xhtml/vocab#next
• dqm:next(dqm)0.532
  

  n/a (use in LOD)

  http://purl.org/dqm-vocabulary/v1/dqm#next

  rdfs:comment Links an instances to the next instance in an ordinal scale. @en

  localName next
• olo:next(olo)0.532
  

  n/a (use in LOD)

  http://purl.org/ontology/olo/core#next

  rdfs:label has next @en

  rdfs:comment Associates the next slot in an ordered list. @en

  localName next

on a 71 réponses (peut-être plus quand vous lirez cet article), et déjà, les trois premières nous conviennent... Quelle utilité d'en créer une 72ème qui ne sera utilisée par personne d'autre que par moi. Prenons la plus populaire : xhv:next

On peut donc écrire (non, je ne met pas le couvercle, vous le mettrez si vous voulez... en plus , y'a des risques de débordement...) les triplets suivants :

{ FaireBouillirEau xhv:next AjouterSel }
{AjouterSel xhv:next VerserPâtes }
{VerserPâtes xhv:next RemuerDeTempsEnTemps }
{VerserPâtes xhv:next Attendre10Min }
{Attendre10Min xhv:next EgoutterPâtes }



On a maintenant une structure cohérente sans trop mettre les pieds dans le plat... de pâtes. Bon ok, c'est nul... Avec VerserPâtes qui possède deux xhv:next : RemuerDetempsEnTemps et Attendre10Min.

On a maintenant tout ce qu'il faut pour compléter notre méthode CuireDesPâtes. on peut par exemple décomposer les étapes... avec les propriétés dc:hasPart, rdf:first et xhv:next
L'étape FaireBouillirEau pourrait être composée d'autres étapes, comme SortirCasserole, RemplirEau, PoserSurGaziniere, AllumerLeFeu... et oui, Johnny...
SortirCasserole se décomposerait en AllerDevantPlacardBasGauche, OuvrirPortePlacardBasGauche, AttrapperCasserole, Reculer, FermerPlacardBasGauche, SeDeplacerVersEvier...


On peut ainsi stocker n'importe quelle méthode sur notre serveur RDF (avec Fuseki), ou sous forme de fichier rdf/owl téléchargeable.
ps : j'ai zappé pas mal de principes RDF, préfixe, etc... pour que ce soit plus clair à un non initié, mais l'intéressé pourra se rendre là : https://fr.wikipedia.org/wiki/Resource_Description_Framework ou là http://www.w3.org/TR/rdf-syntax-grammar/
 ou là en français : https://www.google.fr/webhp?sourceid=chrome-instant&ion=1&espv=2&ie=UTF-8#q=rdf%20francais 

Reste à créer une interface conviviale pour enregistrer, éditer, visualiser les méthodes...

Le systeme multi-agent sous forme de holon

Trouvé ce texte de Descartes dans une des thèses : ( http://sebastian.rodriguez.free.fr/files/ThesisSRodriguez_print.pdf )
Les hommes sont les proies d'une si aveugle curiosité qu'ils conduisent souvent leur esprit par des chemins inconnus, et sans aucune raison d'espérer, mais seulement pour courir leur chance d'y trouver par hasard ce qu'ils cherchent ; comme quelqu'un qui brûlerait d'un désir si brutal de découvrir un trésor, qu'il ne cesserait de courir les rues ça et là, cherchant si par hasard il n'en trouverait pas un qu'un voyageur aurait perdu. C'est ainsi que travaillent presque tous les chimistes, la plupart des géomètres, et plus d'un philosophe ; et certes je ne nie point que parfois ils ne vagabondent avec assez de bonne fortune pour trouver quelque vérité ; je n'admets pas pour autant qu'ils en soient plus habiles, mais seulement plus chanceux. Il vaut cependant bien mieux ne jamais songer à chercher la vérité sur quelque objet que ce soit, que le faire sans méthode : car il est très certain que ces recherches désordonnées et ces méditations obscures troublent la lumière naturelle et aveuglent l'esprit ; et tous ceux qui s'habituent ainsi à marcher dans les ténèbres affaiblissent tant leur vue que par la suite ils ne peuvent plus supporter la lumière du jour ; l'expérience aussi le confirme, puisque nous voyons très souvent ceux qui ne se sont jamais souciés d'étudier porter des jugements bien plus solides et bien plus clairs sur ce qui se présente à eux, que ceux qui ont passé tout leur temps dans les écoles. DESCARTES

Les systèmes multi-agents : 

Qu'est ce qu'un système multi-agent ?
http://www.lirmm.fr/~ferber/publications/LesSMA_Ferber.pdf

Les méthodes de conception de systèmes multi-agent :

Diamond : http://tel.archives-ouvertes.fr/docs/00/18/90/46/PDF/These_Jean-Paul_Jamont_2005.pdf
Aspecs :  http://www.aspecs.org/Home ou en   Pdf

Un agent particulier, le holon : 

Holons dans les systèmes multi-agents[modifier | modifier le code]

Les systèmes multi-agents sont des systèmes composés d'entités logicielles autonomes. Ils sont capables de simuler un système ou de résoudre des problèmes. L'holon peut être vu comme une sorte d'agent récursif : un agent composé d'agents qui, a un niveau donné, a son propre comportement comme un conséquence partielle des comportements de ses composants5. Janus Multiagent Platform est un exemple de plate-forme logicielle capable de faire tourner des holons.

( source Wikipedia :
http://fr.wikipedia.org/wiki/Holon_(philosophie)#Holons_dans_les_syst.C3.A8mes_multi-agents )


Exemlpe de systèmes multi-agent :
Janus Project (Java) : http://www.janus-project.org/Home
Spade (Python) :
Jade (Java) :
Quelque chose en ruby, où autre ? faites-le nous savoir qu'on rajoute l'info .
Dans jade, spade, Janus, les agents respectent les normes de la FIPA pour les communications .
Les systèmes multi-agents ont l'air un peu veillots...
Pour se renseigner sur la programmation des agents :
https://www.google.fr/search?q=programmation+agent+java&oq=java+programmation+ag&aqs=chrome.1.69i57j0.8663j0j4&sourceid=chrome&espv=210&es_sm=93&ie=UTF-8
Un autre type d'agent directement natif dans java (à voir si ça correspond?) : http://blog.xebia.fr/2008/05/02/java-agent-instrumentez-vos-classes/

Pour en savoir plus : 

http://users.dsic.upv.es/~agiret/articulos/JIM2004.pdf

https://www.google.fr/search?q=holon&oq=holon&aqs=chrome..69i57j0l5.1180j0j4&sourceid=chrome&espv=210&es_sm=93&ie=UTF-8#q=holon+multi-agent

Pourquoi du RDF ? pour jouer de la musique ?

- RDF ( resource description Framework) ? c'est un langage permettant de décrire des ressources d'un domaine... (voir wikipedia). Partageable, distribuable, interprétable par les machines....
- Ok ! c'est donc pour ça que tu veux absolument l'utiliser ?
- Oui, distribuable : donc les ressources sont décrites une fois et partagées entre les modules / robots , à condition de gérer la confidentialité des infos ... Et je me suis dit que je pouvais décrire avec la méthode Diamond qui est une méthode pour construire des systèmes multi-agents... J'en ai d'ailleurs fait une première version sur une autre page du blog, c'est diamond.owl. Et je suis en train d'essayer de la visualiser avec Processing.
Par extension, et si j'y arrive, je devrais pouvoir appliquer ce principe :
 [- visualiser / modifier les fichiers RDF/ontologies sous forme de graphes (Processing ? javascript + D3 ou jointjs)
- transmettre des infos à des machines (ordi/robot/module/agent) dans un format interpretable par elles.]
 à n'importe quelle méthode, comme une recette de cuisine, ou la procédure pour faire du café, pour ouvrir un placard ou y ranger les satanés légos qui trainenet.
- N'importe quelle méthode ou procédure ? Pourquoi pas une chanson, alors ? c'est comme une méthode ! Regarde : si on prend par exemple cette page http://www.francetabs.com/tablatures-partitions/brigitte/battez-vous-tab-guitare12488.html où on trouve les tablatures de Brigitte (désolé, je ne suis pas un crack en solfège, mais la suite doit être applicable aussi !)

ACCORDS

    

TABLATURE

d|———————————|——————————|————————————||
a|———————————|——————————|————2—0—————||
e|—12———11———|—10———9———|—0—3————3—0—|| clap-clap
   .tremolo-------------    ¬¬        


d|—–2————4———|——5————7———|—2—————————2——||
a|—–2————6———|—–5———–4———|—2———2—0———2——||
e|—––———––———|————––––––—|—0—3————–3—0—|| clap-clap
   .tremolo-------------     ¬¬


       Em       EmM7          Em7       Em6
Faites-vous la guerre pour me faire la cour
 Em
Maintenant battez-vous
  Em       EmM7    Em7    Em6
Soyez gangsters, soyez voyous
 Em
Maintenant battez-vous
      

(...) 
--Fin de l'extrait.

ça nous dit : à la basse : sur la corde de MI faire les notes 12, puis 11, puis 10, puis 9, puis 0, 3, corde de LA : 2, puis 0, re-corde de MI 3 puis 0, puis Clap-Clap.

Et tu dis que tu peux transmettre ça à une machine ?
- Bien sûr, le format rdf est fait pour ça ! Attend, je te montre ! D'abord , tu lance Protégé, et dedans, tu y décris tout ce dont tu as besoin pour ta méthode, ou tout autre chose ( On pourrais par exemple y décrire la procédure pour une opération chirurgicale ( ;-) Oh Coco... Private Joke !) .
Ensuite tu décris des Classes qui regroupent des éléments de même type, avec des sous classes éventuellement, puis des Entités (ou des Individuals) avec des propriétés.
Pour notre exemple, on pourra par exemple creer une classe Note, une classe Accord, une classe Corde, une classe Position, c'est à toi de décrire ton domaine comme tu le souhaite.
Deux personnes différentes pourront décrire le même domaine de deux manières différentes... ce n'est pas un problème, on pourra toujours rapprocher ensuite deux ontologies...
Dans diamond.owl, j'ai utilisé des Classes Etape et des propriétés first (pour indiquer la première Etape) puis des proprietes next pour lier les différents Individuals ou entités...
Un accord peut être décrit comme un ensemble de 3 notes...
On peut dans le même fichier décrire à la fois tous les instruments, et n'afficher (on ne jouer que les bonnes informations en fonction des requêtes).
Exemple qui ne fonctionnera pas en l'état mais possible :  SELECT Accord WHERE {?Accord ?Instrument ?Guitare} ORDERBY ?Ordre

Essaie Protégé,  si tu veux un exemple : tu peux récupérer diamond-first.owl, et si tu veux des infos sur comment utiliser Protégé pour décrire un domaine, tu peux aller voir tout en bas de cet article : http://smag0.blogspot.fr/2014/03/creer-une-interface-pour-visualiser-les.html et récupérer le tutoriel Pizza-Gloria

+++ On peut même certainement s'amuser avec les machines à états finis dans une Ontologie... à voir : http://www.w3.org/TR/2014/CR-scxml-20140313/