如何使用 Pellet 查找逻辑上等价的组概念

Question

事实上，我使用java prgramation和OWL API在OWL2语言上定义了一个本体。我将所需的 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;
  }

我需要 Pellet 的 java 代码，它允许检测组逻辑上等效的概念。我将感谢您的帮助。提前致谢

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>的集合，每个都包含等价的类。节点在节点集中的顺序以及节点中 OWLClasses 的顺序没有任何作用，并且可能会从一个调用更改为下一个调用。

来自 javadoc OWLReasoner

节点推理器接口包含返回NodeSet对象的方法。这些是一组Node对象。节点包含实体。对于类的Node<OWLClass>，节点中的每个类在根本体的导入闭包方面等效于节点中的其他类。对于对象属性的Node<OWLObjectProperty>，节点中的每个对象属性在根本体的导入闭包方面等效于节点中的其他对象属性。对于数据属性的节点，节点中的每个数据属性在根本体的导入闭包方面等效于节点中的其他数据属性。对于命名个体的节点，节点中的每个个体在根本体的导入闭包方面与节点中的其他个体相同。

Answer 2

注意：此答案中的方法还可以，但它基于错误的假设，即正在使用耶拿 API(问题的原始版本中没有显示太多代码(。

这实际上更像是一个关于如何使用Jena的API来处理模型的问题，因为Pellet可以与其他API(例如OWLAPI(一起使用，在这些情况下，如何检索这些信息会有所不同。 不过，到目前为止，您显示的代码似乎正在使用耶拿。 这里要考虑的主要方法是：

• 列出所有等效类对
• 对于某个特定类，列出所有等效类

下面的代码显示了如何同时执行这两项操作。 请注意，说您列出所有等效类并不完全正确，因为其中有无限多个类。 例如，

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