Как найти группы логически эквивалентных понятий с помощью Pellet?

Question

Фактически, я создаю онтологию, определенную на языке OWL2, используя Java-программу с OWL API.Я интегрирую необходимый jar в свой проект, чтобы использовать механизм вывода Pellet.Мой вопрос заключается в том, как я могу обнаружить в своей онтологии группы понятий, которые логически эквивалентны?вот код, который я использую 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;
  }

Мне нужен Java-код для Pellet, который позволяет обнаруживать группы логически эквивалентных понятий.Буду благодарен за вашу помощь.заранее спасибо

Answer 1

В OWLAPI все результаты OWLReasoner которые относятся к типу Node и NodeSet состоят из наборов эквивалентных сущностей.

Для OWLNamedIndividual, OWLReasoner::getSameIndividuals() возвращает Node<OWLNamedIndividual> объект, который содержит всех людей, которые, как предполагается, являются sameAs друг друга.

Также можно запросить экземпляры класса:OWLReasoner::getInstances() вернет NodeSet<OWLIndividual>, который представляет собой совокупность Node объекты, каждый из которых соответствует набору OWLNamedIndividual объекты, которые также sameAs друг друга.

То же самое относится к под/супер/эквивалентным классам и свойствам.

Изменить, чтобы включить комментарии:

Чтобы получить всех поименованных индивидуумов в онтологии, сгруппированных по тем же параметрам, что и в классах эквивалентности, подход состоит в том, чтобы запросить все экземпляры owl:Thing

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

NodeSet содержит узлы (в произвольном порядке);каждый узел содержит OWLNamedIndividual объекты в произвольном порядке.Все индивиды в одном узле одинаковы друг с другом, т. е. каждый может считаться представителем своего класса эквивалентности.Понятия канонического представителя не существует.

Аналогично, чтобы получить все классы эквивалентности для OWLClass

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

Это коллекция Node<OWLClass>, каждый из которых содержит эквивалентные классы.Порядок, в котором узлы находятся в NodeSet, и порядок OWLClasses в узле не играют никакой роли и могут меняться от одного вызова к другому.

Из OWLReasoner Javadoc

Узлы интерфейс рассуждения содержит методы, которые возвращаются NodeSet объекты.Это наборы Node объекты.Узел содержит сущности.Для Node<OWLClass> Из всех классов каждый класс в узле эквивалентен другим классам в узле относительно замыкания импорта корневой онтологии.Для Node<OWLObjectProperty> Из свойств объекта каждое свойство объекта в узле эквивалентно другим свойствам объекта в узле относительно закрытия импорта корневой онтологии.Для узла свойств данных каждое свойство данных в узле эквивалентно другим свойствам данных в узле относительно закрытия импорта корневой онтологии.Для узла именованных индивидуумов каждый индивидуум в узле идентичен другим индивидуумам в узле в отношении закрытия импорта корневой онтологии.

Answer 2

Примечание. Подход в этом ответе в порядке, но он основан на ошибочном предположении, что используется API jena (не так много код был показан в оригинальной версии вопроса). < / P >.

Это действительно больше вопрос о том, как использовать API jena для работы с моделями, поскольку гранул можно использовать с другими API (e.g, owlapi) и как вы получите эту информацию, будут отличаться в этих случаях. Код, который вы показали до сих пор, хотя, кажется, используют Jena. Основные подходы к рассмотрению здесь:

.
• Перечисление всех пар эквивалентных классов
• для определенного класса, перечислите все эквивалентные классы

Код ниже показывает, как сделать обоими. Обратите внимание, что не строго правильно сказать, что вы перечисляете эквивалентные классы , потому что есть бесконечно многие из них. E.G.,

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

Строго говоря, это выражения классов , и это то, что может быть больше, чем один из. Как только вы определили, например, a ≡ b, есть действительно только один класс , просто случилось два класса, которые обозначают этот класс. Это как спрашивать, «какие числа равны 2?» Ответ «только 2», тогда как к вопросу «какие арифметические выражения имеют значение 2?» Ответ на это {2, 1 + 1, 2 × 1, 4/2, ...}. Я только указываю на это, потому что я не уверен, что Pellet результатов даст вам, хотя я ожидаю, что это просто будет искать выражения классов, которые уже присутствуют в вашей онтологии.

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() );
        }
    }
}

.