0

事实上，我使用带有 OWL API 的 java prgramation 在 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 代码，它允许检测组逻辑上等效的概念。我会很感激你的帮助。提前致谢

4

2 回答 2

1

注意：此答案中的方法是可以的，但它基于错误假设正在使用 Jena API（问题的原始版本中显示的代码不多）。

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

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

下面的代码显示了如何做到这两点。请注意，说您列出所有等效类并不完全正确，因为其中有无数个。例如，

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() );
        }
    }
}
于 2014-06-05T10:46:06.900 回答
1

在 OWLAPI 中，所有结果OWLReasoner都是类型的Node，并且NodeSet由等效实体集组成。

对于OWLNamedIndividual，OWLReasoner::getSameIndividuals()返回一个Node<OWLNamedIndividual>对象，其中包含推断为sameAs彼此的所有个体。

也可以请求一个类的实例： OWLReasoner::getInstances()将返回 a NodeSet<OWLIndividual>，它是一个对象的集合 Node，每个对象对应于一组彼此相同的OWLNamedIndividual对象sameAs。

这同样适用于子/超级/等效类和属性。

编辑以包括评论：

为了得到一个本体中的所有命名个体，在等价类中按 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

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

于 2014-06-05T20:34:57.857 回答