Intégration d'ontologie dans les actes de communication inter-agents

IV.1 Définition de l'ontologie

Une ontologie en JADE est une instance de la classe jade.content.onto.Ontology à laquelle les schémas définissant la structure des types de prédicat, d'actions d'agent et de concept concernant le domaine adressé ont été ajoutés. Ces schémas sont des instances des classes PredicateSchema, AgentActionSchema et ConceptSchema incluses dans le package jade. content.schema. Ces classes ont des méthodes au moyen desquelles il est possible de déclarer les champs qui définissent la structure de chaque type de prédicat, d'action d'agent et de concept. Comme une ontologie est fondamentalement une collection de schémas qui typiquement n'évoluent pas pendant la durée de vie d'un agent, il est plus pratique de déclarer l'ontologie comme un objet singleton et de définir une classe qui étend le package jade.content.onto.Ontology avec une méthode d'accès statique à cet objet singleton. Ceci permet de partager le même objet ontologie (et tous les schémas inclus) entre différents agents d'une même JVM.

Dans notre application, concernant la vente de livres, nous définissons trois concepts (article, livre, Auteur), deux prédicats (coût/cost), (possède/owns) et une action d'agent (vente/sell). En outre nous devrons traiter le concept AID¹¹.Même si ce concept n'a pas besoin d'être défini puisque toute ontologie définie dans JADE étend automatiquement une ontologie de base (représentée comme un objet singleton de la classe jade.content.onto.BasicOntology) qui inclut les schémas:

· Les types primitifs (String, Integer, Float...).

· Quelques prédicats, actions d'agent et concepts génériques à travers lesquels le concept d'AID identifie un agent.

Afin de déclarer que l'ontologie O1 étend l'ontologie O2 (c.-à-d. tous les prédicats, les actions d'agent et les concepts inclus dans O2 sont également inclus dans O1) il suffi de passer O2 comme paramètre dans la construction de O1.

11 AID : identification de l'agent.

64

L'ontologie pour le domaine de vente de livres peut être définie comme suit:

import jade.content.onto.*;

import jade.content.schema.*;

public class Livre-ontologie extends Ontology {// le nom qui identifie l'ontologie public static final String ONTOLOGY_NAME = "Livre-ontologie"; // VOCABULAIRE

public static final String ITEM = "Item";

public static final String ITEM_SERIAL = "serial-number";

public static final String LIVRE = "Livre";

public static final String LIVRE_TITRE = "titre";

public static final String LIVRE_AUTEUR = "Auteur";

public static final String AUTEUR = "Auteur";

public static final String AUTEUR_NOM = "nom";

public static final String AUTEUR_PRENOM = "maison";

public static final String OWNS = "Owns";

public static final String OWNS_OWNER = "owner";

public static final String OWNS_ITEM = "item";

public static final String SELL = "Sell";

public static final String SELL_BUYER = "buyer";

public static final String SELL_ITEM = "item";

private static Ontology theInstance = new Livre-ontologie();

public static Ontology getInstance() {

return theInstance;

}

private LivreOntologie() {

super(ONTOLOGY_NAME, BasicOntology.getInstance())

try {

add(new ConceptSchema(ITEM), Item.class);

add(new ConceptSchema(LIVRE), Livre.class);

add(new ConceptSchema(AUTEUR), Auteur.class); add(new PredicateSchema(OWNS), Owns.class); add(new AgentActionSchema(SELL), Sell.class);

ConceptSchema cs = (ConceptSchema). getSchema(ITEM); cs.add(ITEM_SERIAL,(PrimitiveSchema).getSchema(BasicOntology.INTEGER),

ObjectSchema.OPTIONAL);

cs = (ConceptSchema). getSchema(LIVRE);

cs.addSuperSchema((ConceptSchema). getS chema(ITEM)); cs.add(LIVRE_TITRE,(PrimitiveSchema).getSchema(BasicOntology.String));

cs.add(AUTEUR, (ConceptSchema). getSchema(AUTEUR), 1 ,ObjectSchema.UNLIMITED);

cs = (ConceptSchema) .getSchema(AUTEUR);

cs.add(AUTEUR_NOM, (PrimitiveSchema). getSchema(BasicOntology.STRING));

cs.add(AUTEUR_PRENOM,(PrimitiveSchema).getSchema(BasicOntology.INTEGER),
ObjectSchema.OPTIONAL);

PredicateSchema ps = (PredicateSchema).getSchema(OWNS); ps.add(OWNS_OWNER,(ConceptSchema).getSchema(BasicOntology.AID)); ps.add(OWNS_ITEM, (ConceptSchema). getSchema(ITEM));

AgentActionSchema as = (AgentActionSchema).getSchema(SELL);

as.add(SELL_ITEM, (ConceptSchema) getSchema(ITEM));

as.add(SELL_BUYER, (ConceptSchema ).getSchema(BasicOntology.AID)); }

catch (OntologyException oe) {

oe.printStackTrace();

}

}

Toutes les classes de XXXSchema sont incluses dans le package jade.content.schema .A partir du code ci-dessus nous pouvons voir que:

· Chaque schéma ajouté à l'ontologie est associé à une classe Java, par exemple le schéma pour le concept Livre est associé à la classe Livre.java. Tout en utilisant l'ontologie définie, les expressions indiquant des livres seront des instances de la classe Livre. Ces classes Java doivent avoir une structure appropriée comme il est décrit dans la section IV.2.

· Chaque champ dans un schéma a un nom et un type, c. -à-d. les valeurs pour cette propriété doivent être conformes au schéma indiqué.

· Un champ peut être déclaré comme OPTIONAL pour préciser que sa valeur peut être nulle. Autrement un champ est considéré MANDATORY. Si une valeur nulle pour un champ MANDATORY est rencontrée dans la validation de l'expression de contenu, une exception (OntologyException) est levée.

· Un schéma peut avoir un certain nombre de super-schémas. Ceci permet de définir des rapports de spécialisation/généralisation parmi des concepts. Par exemple le schéma du livre a le schéma d'article comme super-type. Cela signifie que le livre est un type d'article et donc chaque instance de livre est également un instance d'article.

66