Comment créer une méthode pour Smag0, la méthode Diamond, au format RDF

On peut maintenant enregistrer un nouveau projet ou une information à transmettre à sa maison, grâce à l'appli Coolitude4, ou bien directement sur le site http://smag-smag0.rhcloud.com/visu.jsp.

Ensuite, pour nous aider à réaliser ce projet, ou pour aider le système à analyser l'information qu'on lui a envoyer, nous allons de voir utiliser une ou plusieurs méthode. Cet article décrit comment créer une nouvelle méthode et comment l'intégrer au système Smag0. On pourra de la même manière créer d'autres méthodes, des procédures métiers, des recettes de cuisine, des manières de ranger une chambre. Ces méthodes sont partageables et utilisables par plusieurs systèmes, elles devront également être personnalisables, selon l'envie, le contexte de chacun.

J'avais dans un premier temps, fait un premier test pour modéliser la méthode Diamond en me basant sur ce document : DIAMOND : Une approche pour la conception de systèmes multi-agents embarqués par Jean-Paul Jamont, et ça nous donnait ceci : http://smag0.rww.io/diamond.owl.

On pourra aussi se pencher sur la méthode ASPECS à laquelle est étroitement liée Janus.

J'ai depuis approfondi mes connaissances en RDF, et il apparaît opportun, d'utiliser au maximum des vocabulaires déjà existants, pour renforcer la compatibilité et la portabilité d'un méthode.

pour un rappel (ou une découverte) sur RDF et ses triplets, un petit coup d'oeil sur Wikipedia.

Une méthode est tout d'abord une séquence ordonnée d'instructions, ce qui se traduit en RDF par le triplet suivant : 

{ MethodeDiamond        rdf:type     rdf:Seq }

avec rdf:type : http://www.w3.org/TR/rdf-schema/#ch_type : 

rdf:type est une instance de rdf:Property qui est utilisé pour indiquer qu'une ressource est une instance d'une classe.Un triplet de la forme: R rdf:type Cstipule que C est une instance de rdfs:Class et R est une instance de C.Le rdfs:domain de rdf:type est rdfs:Resource. Les rdfs:range de rdf:type est rdfs:Class.

et rdf:Seq : http://www.w3.org/TR/rdf-schema/#ch_seq :

Le rdf:Seq est la classe de «séquence» conteneurs RDF. Il est une sous-classe de rdfs:Container. Bien que formellement il est pas différent d'un rdf:Bag ou un rdf:Alt. rdf:Seq est utilisée conventionnellement pour indiquer à un lecteur humain que l'ordre numérique des propriétés d'appartenance de conteneur du conteneur est destiné à être significatif.

La méthode Diamond (enfin, comme je l'ai comprise ;-)) se décompose en 4 étapes majeures : 

1. A. Définition des besoins
2. B. Analyse du système Multi-Agents
3. C. Conception Générique
4. D. Implantation

ce qui se traduira par les triplets suivants

{ MethodeDiamond rdf:_1 DefinitionDesBesoins }

{ MethodeDiamond   rdf:_2 AnalyseSMA }

{ MethodeDiamond   rdf:_3 ConceptionGenerique }

{ MethodeDiamond   rdf:_4 Implantation }

Chacun de ces étapes majeures étant elle même une séquence  composée d'autres étapes, on continuera donc en décrivant l'étape DefinitionDesBesoins par les triplets suivants : 

{ DefinitionDesBesoins rdf:type  rdf:Seq  }

{ DefinitionDesBesoins rdf:_1 ApprochePreliminaire }

{ DefinitionDesBesoins rdf:_2 EtudeActeurs }

{ DefinitionDesBesoins rdf:_3 EtudeCasUtilisation }

{ DefinitionDesBesoins rdf:_4 EtudeBesoinsService }

{ DefinitionDesBesoins rdf:_5 EtudeModeMarcheArret }

et ainsi de suite,
pour plus d'infos sur comment construire une ontologie :
http://python.espe-bretagne.fr/master-hst-ue9-2/wp-content/uploads/2013/03/Tutoriel-Pizza-gloria-1.pdf
http://protegewiki.stanford.edu/wiki/Protege4Pizzas10Minutes
http://protegewiki.stanford.edu/wiki/Protege4UserDocs

Bien , maintenant, passons à la pratique.

Commencez par télécharger et exécuter Protégé2000,
ensuite nommez votre ontologie comme décrit dans les tutoriels juste au dessus (si vous bloquez à ce niveau, demandez de l'aide dans un des groupes de discussion du blog, ou en commentaire de cet article), et importez le vocabulaire rdf : http://www.w3.org/1999/02/22-rdf-syntax-ns#

dans votre ontologie.
Cela nous donnera accès aux classes rdf:Seq et aux propriétés rdf:type...
Ensuite, pour avoir accès à la numérotation, on va aussi importer le vocabulaire rdfs : http://www.w3.org/1999/02/22-rdf-syntax-ns#

dans objectPropertyHierarchie, ajouter des sous-propriétés à la propriété "member" telles que celles-ci : 
http://www.w3.org/1999/02/22-rdf-syntax-ns#_1
http://www.w3.org/1999/02/22-rdf-syntax-ns#_2
http://www.w3.org/1999/02/22-rdf-syntax-ns#_3
...

article), et importez le vocabulaire r
Creez une classe Methode sous la classe Thing, et créez une instance "MaMethode" de type "Methode".

•  ajoutez le type "Seq" à "MaMethode". --> ceci nous donnera le triplet { MethodeDiamond        rdf:type     rdf:Seq }
• ensuite utilisez les propriétés _1, _2 que vous avez créé sous la propéiété member, et créez les instances  DefinitionDesBesoins, AnalyseSMA  ConceptionGenerique  Implantation ,
  ce qui nous donnera les triplets :
  
  { MethodeDiamond rdf:_1 DefinitionDesBesoins }
  { MethodeDiamond   rdf:_2 AnalyseSMA }
  { MethodeDiamond   rdf:_3 ConceptionGenerique }
  { MethodeDiamond   rdf:_4 Implantation }

On peut ensuite ajouter le type Seq à ces quatres instances et continuer, en décrivant les sous-étapes de ces étapes, et ainsi de suite...

Le but étant d'avoir une structure récursive, identique pour toutes les méthodes, afin de pouvoir être utilisé de manière transparente par différentes applications.

On a décrit ici comment construire l'ontologie. on pourra ensuite la stocker sur http://rww.io/ (attention, la survie de ce site n'est pas garantie), ou sur un truc comme https://github.com/scenaristeur/smagserver/tree/master/src/main/webapp/ontologies, pour avoir une possibilité d'évolution, de versionning sur l'ontologie.

Pour l'instant, une première version là : http://smag-smag0.rhcloud.com/ontologies/diamondMethode.owl

reste à ajouter un formulaire sur Smag0 pour intégrer de nouvelles ontologies.

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/

Interface : Visualisation d'une ontologie owl créée avec Protégé, convertie au format Json pour l'integrer à D3.js ou exhibit

Pour créer une visualisation d'ontologie dans une interface Web.

Démarrer le serveur Fuseki avec les options suivantes :
fuseki-server --update --mem /diamond
ensuite sur le serveur fuseki (http://127.0.0.1:3333), utiliser le cadre File upload au bas de la page sparql.tpl.
Puis sur la même page, dans le cadre SPARQL Query,  lancer la requête (en selectionnant OUTput : JSON) :
SELECT  *  WHERE {?Sujet ?Propriete ?Objet}

Télécharger le fichier nouvellement créé et le renommer avec l'extension .json

Ce fichier peut maintenant être directement utilisable par les moteurs de visualisation javascript tels que D3 ou Exhibit.

par exemple pour l'integrer dans une page html utilisant d3.js, utilisez le code suivant :

<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="utf-8">
<title>D3 Test</title>
<script type="text/javascript" src="d3/d3.js"></script>
</head>
<body>
<script type="text/javascript">
// DATA

d3.json("data/diamond.json", function(diamond) {
console.log(diamond);
});

//  test paragraphe
d3.select("body")
.append("p")
.text("Smag0!");
</script>
</body>
</html>

ensuite vous pouvez vérifier l'insertion des données dans la page en utilisant la console de développement fournie par GoogleChrome , ou Firefox  :

GRRRRRR ! Après  2 jours à me prendre la tête, je me rend compte que le Json de Fuseki n'est pas le même que le Json de D3.js... et que je ne suis pas le premier à me prendre la tête dessus...
Sommes nous bloqués ? Non, on va le tenter en csv d'après la procédure décrite sur ce blog : http://www.d3noob.org/2013/03/d3js-force-directed-graph-example-basic.html

cet article semble également interessant http://graus.nu/thesis/algorithm-performance-measurement-confusion-matrix/ parlant de matrice de confusion dans le domaine du Machine Learning (aprentissage des machines)

Sinon une autre option pourrait-être d'utiliser : http://jointjs.com/demos (mais y'a un truc à voir avec la license Free / pas free ?)

Le but étant d'obtenir quelque chose comme ça : http://bl.ocks.org/d3noob/5141278

et pour le fun, j'aime bien celui-là : http://bl.ocks.org/mbostock/1249681

reprendre aussi l'idée de cluster : http://bl.ocks.org/mbostock/7881887

et le rendre en plus zoomable : http://bl.ocks.org/mbostock/7607535 et oui, rien que ça...
Une autre idée du cluster : https://github.com/Leaflet/Leaflet.markercluster

De la méthode Diamond pour SMA basée sur une Ontologie

Pour créer une interface facilitant la description / gestion du système multi-agent, on va s'appuyer sur des méthode de conception de systèmes multi-agents.
Deux méthodes pourront ici nous être utiles :
- la méthode DIAMOND: UNE APPROCHE POUR LA CONCEPTION
DE SYSTEMES MULTI-AGENTS EMBARQUES proposant un cycle de vie en spirale, semble être un bon début pour se lancer .
- on pourra faire la même chose avec la méthode ASPECS utilisée par Janus-Project et qui prend en compte la notion de holon ( plusieurs niveaux hiérarchique, décomposition d'agents)

Pour une interface Utilisateur  :
javascript avec ontologyonline.org ou Java avec EulerGui/Déductions (vidéo de présentation du cadriciel)

OntologyOnline : Un petit peu de javascript (grâce à http://ontologyonline.org/), permet d'afficher l'ontologie (en cours d'élaboration) de la méthode Diamond   : un premier test de ce que ça donne : jowl.zip
 (à décompresser et lancer le fichier jOWLBrowser.html)
dernière mise à jour du fichier diamond.owl

TODO : un petit bug dans ontologyonline : Seuls les 'Individuals' possédant le type 'Thing' sont affichés dans l'onglet 'Individuals'

mail envoyé au développeur : 
Hi, it seem that only the 'Individuals' with the type "Thing" might appear like this one : 

    <!-- http://www.w3.org/TR/2003/PR-owl-guide-20031209/wine#Ola -->

    <owl:Thing rdf:about="&vin;Ola">

        <rdf:type rdf:resource="&owl;NamedIndividual"/>

        <rdf:type rdf:resource="&vin;Test"/>

    </owl:Thing>

But those who don't have the type 'Thing' don't appear, like this one : 

    <!-- http://www.w3.org/TR/2003/PR-owl-guide-20031209/wine#Ola -->

    <owl:NamedIndividual rdf:about="&vin;Ola">

        <rdf:type rdf:resource="&vin;Test"/>

    </owl:NamedIndividual>

Do you have any idea of the file I have to modify ?

Thanks


pas de réponse du développeur de ontologieOnline

-> on continue l'investigation