Comment trouver des groupes de concepts logiquement équivalents à l'aide de Pellet ?

Question

En fait, je crée une ontologie définie sur le langage OWL2 en utilisant la programmation Java avec l'API OWL.J'intègre le jar requis dans mon projet pour utiliser le moteur d'inférence Pellet.Ma question est de savoir comment détecter dans mon ontologie des groupes de concepts logiquement équivalents ?voici le code que j'utilise Pellet.

 import java.io.File;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.semanticweb.owlapi.apibinding.OWLManager;
import org.semanticweb.owlapi.io.StreamDocumentTarget;
import org.semanticweb.owlapi.model.IRI;
import org.semanticweb.owlapi.model.OWLAxiom;
import org.semanticweb.owlapi.model.OWLClass;
import org.semanticweb.owlapi.model.OWLDataFactory;
import org.semanticweb.owlapi.model.OWLNamedIndividual;
import org.semanticweb.owlapi.model.OWLObjectProperty;
import org.semanticweb.owlapi.model.OWLOntology;
import org.semanticweb.owlapi.model.OWLOntologyChange;
import org.semanticweb.owlapi.model.OWLOntologyCreationException;
import org.semanticweb.owlapi.model.OWLOntologyManager;
import org.semanticweb.owlapi.model.OWLOntologyStorageException;
import com.clarkparsia.pellet.owlapiv3.PelletReasoner;
import com.clarkparsia.pellet.owlapiv3.PelletReasonerFactory;
import org.mindswap.pellet.KnowledgeBase;







/**
 *
 * @author hela
 */
public class Owl {

  public  void createNewOnto(List<String[][]> cps, LinkedList<Map<String, String>> rel, String uri ) throws OWLOntologyCreationException,
        OWLOntologyStorageException {
     OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
        OWLDataFactory factory = manager.getOWLDataFactory();
        IRI iri = IRI.create("http://www.co-ode.org/ontologies/Annot2Onto.owl");
        OWLOntology ontology = manager.createOntology(iri); 

OWLObjectProperty subTopicOf =factory.getOWLObjectProperty(IRI.create(iri+"/#sub-topicOf"));
OWLObjectProperty kindOf =factory.getOWLObjectProperty(IRI.create(iri+"/#kindOf"));
OWLClass thing = factory.getOWLClass(IRI.create(iri+"/#OWLThing"));
  manager.addAxiom(ontology, factory.getOWLDeclarationAxiom(thing));
 Set<OWLAxiom> genders = new HashSet<OWLAxiom>();
 for(Map<String, String> rmp : rel){
     Set<OWLNamedIndividual> classes =ontology.getIndividualsInSignature();
  List< OWLNamedIndividual> listc = new ArrayList(classes);
   IRI ir = IRI.create(iri+"/#"+rmp.get("concept1"));
    OWLNamedIndividual c1=null;

 if(ontology.containsClassInSignature(ir)){
     int i=0;

     while(i<listc.size()&& c1==null){
         if(listc.get(i).toString().compareTo("<"+ir.toString()+">")==0){
             c1=listc.get(i);

              manager.addAxiom(ontology, factory.getOWLDeclarationAxiom(c1));
             manager.addAxiom(ontology, factory.getOWLClassAssertionAxiom(thing, c1));
         }


         i++;
     }
 }

 else {
      c1 = factory.getOWLNamedIndividual(IRI.create(iri+"/#"+rmp.get("concept1")));

        //manager.addAxiom(ontology, factory.getOWLDeclarationAxiom(c1));
        manager.addAxiom(ontology, factory.getOWLClassAssertionAxiom(thing, c1));
 }

 IRI ir2 = IRI.create(iri+"/#"+rmp.get("concept2"));
    OWLNamedIndividual c2=null;
 if(ontology.containsIndividualInSignature(ir2)){
     int i=0;

     while(i<listc.size()&& c2==null){

         if(listc.get(i).toString().compareTo("<"+ir2.toString()+">")==0){
             c2=listc.get(i);
              System.out.println("concept2 = "+c2.toString());
             manager.addAxiom(ontology, factory.getOWLDeclarationAxiom(c2));
               manager.addAxiom(ontology, factory.getOWLClassAssertionAxiom(thing, c2));
         }
         i++;
     }
 }

 else{ 
      c2 = factory.getOWLNamedIndividual(IRI.create(iri+"/#"+rmp.get("concept2")));

       //manager.addAxiom(ontology, factory.getOWLDeclarationAxiom(c2));
        manager.addAxiom(ontology, factory.getOWLClassAssertionAxiom(thing, c2));
 }

if(rmp.get("relation").compareTo("kind of")==0){
//domainAxiom = factory.getOWLObjectPropertyDomainAxiom(sorteDe,c1);
//rangeAxiom = factory.getOWLObjectPropertyRangeAxiom(sorteDe,c2);

genders.add(factory.getOWLObjectPropertyAssertionAxiom(kindOf, c1,
                c2));
}

else{

  genders.add(factory.getOWLObjectPropertyAssertionAxiom(subTopicOf, c1,c2));


}

    String[][] cp1 = this.getConcept(cps,rmp.get("concept1"));
    String[][] cp2 = this.getConcept(cps,rmp.get("concept2") );
    cps.remove(cp2);
    cps.remove(cp1);
    // Now we apply the change using the manager.
    //manager.applyChange(addAxiom1);
 }
    List<OWLOntologyChange> la=manager.addAxioms(ontology, genders);
    manager.applyChanges(la);

for(String[][] ct: cps){
    OWLNamedIndividual res=factory.getOWLNamedIndividual(IRI.create(iri+"/#"+ct[0][0]));
       manager.addAxiom(ontology, factory.getOWLDeclarationAxiom(res));
      manager.addAxiom(ontology, factory.getOWLClassAssertionAxiom(thing, res));

}

File file = new File(uri+"/Annot2Onto.owl");
PelletReasoner reasoner = PelletReasonerFactory.getInstance().createNonBufferingReasoner( ontology );
      manager.addOntologyChangeListener( reasoner );
reasoner.flush();
System.out.println(reasoner.isConsistent());
KnowledgeBase kb = reasoner.getKB();
kb.get
    manager.saveOntology(ontology, IRI.create(file.toURI()));
    manager.saveOntology(ontology, new StreamDocumentTarget(System.out));

}
  public String[][] getConcept(List<String[][]> cps, String s){
      String[][] cp =null;
      int i=0;
      while((i<cps.size()) && (cp==null) ){
          if(cps.get(i)[0][0].compareTo(s)==0)
              cp=cps.get(i);
      i++;
      }
      return cp;
  }

J'ai besoin du code java pour Pellet qui permet de détecter des groupes de concepts logiquement équivalents.Je serai reconnaissant pour votre aide.Merci d'avance

Answer 1

Dans OWLAPI, tous les résultats de OWLReasoner qui sont du type Node et NodeSet sont constitués d’ensembles d’entités équivalentes.

Pour OWLNamedIndividual, OWLReasoner::getSameIndividuals() renvoie un Node<OWLNamedIndividual> objet, qui contient tous les individus supposés être sameAs l'un l'autre.

Il est également possible de demander les instances d'une classe :OWLReasoner::getInstances() renverra un NodeSet<OWLIndividual>, qui est une collection de Node objets, chacun correspondant à un ensemble de OWLNamedIndividual des objets qui sont également sameAs l'un l'autre.

Il en va de même pour les classes et propriétés sous/super/équivalentes.

Modifier pour inclure des commentaires :

Pour obtenir tous les individus nommés dans une ontologie, regroupés par mêmes, comme dans les classes d'équivalence, une approche consiste à demander toutes les instances de owl:Thing

NodeSet<OWLNamedIndividual> individuals = reasoner.getInstances(dataFactory.getOWLThing(), false);

Un NodeSet contient des nœuds (sans ordre particulier) ;chaque nœud contient OWLNamedIndividual objets, sans ordre particulier.Tous les individus d'un même nœud sont identiques les uns aux autres, c'est-à-dire que chacun peut être considéré comme un représentant de sa classe d'équivalence.Il n'y a pas de notion de représentant canonique.

De même, pour obtenir toutes les classes d’équivalence pour OWLClass

NodeSet<OWLClass> classes = reasoner.getSubClasses(dataFactory.getOWLThing(), false);

Il s'agit d'une collection de Node<OWLClass>, dont chacun contient des classes équivalentes.L'ordre dans lequel les Nodes sont trouvés dans le NodeSet, et l'ordre des OWLClasses dans un Node, ne jouent aucun rôle et peuvent changer d'un appel à l'autre.

Du OWLReasoner javadoc

NODES L'interface du raisonnement contient des méthodes qui renvoient NodeSet objets.Ce sont des ensembles de Node objets.Un nœud contient des entités.Pour un Node<OWLClass> de classes, chaque classe du nœud est équivalente aux autres classes du nœud en ce qui concerne la fermeture des importations de l'ontologie racine.Pour un Node<OWLObjectProperty> des propriétés d'objet, chaque propriété d'objet dans le nœud est équivalente aux autres propriétés d'objet dans le nœud en ce qui concerne la fermeture des importations de l'ontologie racine.Pour un nœud de propriétés de données, chaque propriété de données du nœud est équivalente aux autres propriétés de données du nœud en ce qui concerne la fermeture des importations de l'ontologie racine.Pour un nœud d'individus nommés, chaque individu du nœud est le même que les autres individus du nœud en ce qui concerne la fermeture des importations de l'ontologie racine.

Answer 2

Remarque: l'approche de cette réponse est correcte, mais elle repose sur l'hypothèse erronée que l'API de Jena était utilisée (pas beaucoup de code a été montré dans la version originale de la question). < / p>

C'est vraiment une question sur la manière d'utiliser l'API de Jena pour travailler avec des modèles, car Pellet peut être utilisé avec d'autres API (par exemple, OLLAPAPI) et la manière dont vous récupérerez ces informations seront différentes dans ces cas. Le code que vous avez montré jusqu'à présent, cependant, semble utiliser Jena. Les principales approches à prendre en compte sont:

• Liste toutes paires de classes équivalentes
• Pour une classe particulière, répertoriez toutes les classes équivalentes

Le code ci-dessous montre comment faire les deux. Notez que ce n'est pas strictement correct de dire que vous inscrivez tous les classes équivalentes , car il y a une infinité de ces. Par exemple,

a ≡ A ⊓ ⊤ A ⊔ ⊥ A ⊓ A ⊓ ⊓

Strictement parler, ce sont expressions de classe , et c'est ce qui peut y avoir plus d'une. Une fois que vous avez déterminé, par exemple, un ≡ B, il n'y a vraiment qu'un classe , il y a juste deux expressions de classe qui indiquent cette classe. C'est une sorte de choix, "quels nombres sont égaux à 2?" La réponse est "seulement 2", alors que la question "Quelles expressions arithmétiques ont la valeur 2?" La réponse à celle-ci est {2, 1 + 1, 2 × 1, 4/2, ...}. Je ne le souligne que parce que je ne suis pas sûr que les résultats des résultats vous donneront, bien que je m'attends à ce qu'elles recherchent des expressions de classe déjà présentes dans votre ontologie.

import org.mindswap.pellet.jena.PelletReasonerFactory;

import com.hp.hpl.jena.ontology.OntClass;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.RDFNode;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.util.iterator.ExtendedIterator;
import com.hp.hpl.jena.vocabulary.OWL;

public class GetEquivalentClassesExample {
    public static void main(String[] args) {
        /*
         * Create an OntModel with an attached Pellet reasoner.
         */
        OntModel model = ModelFactory.createOntologyModel( PelletReasonerFactory.THE_SPEC );

        /*
         * Load your data.
         */
        model.read( "..." );

        /*
         * To list all pairs of equivalent classes, you can just list
         * the statements with the property owl:equivalentClass
         */
        StmtIterator s = model.listStatements( null, OWL.equivalentClass, (RDFNode) null );
        while ( s.hasNext() ) { 
            System.out.println( s.next() );
        }

        /*
         * If you just want the classes that are equivalent to some particular
         * class, you can get a reference to that class, and then ask for its
         * equivalent classes.
         */
        OntClass klass = model.getOntClass( "..." );
        ExtendedIterator<OntClass> c = klass.listEquivalentClasses();
        while ( c.hasNext() ) {
            System.out.println( c.next() );
        }
    }
}