Pellet을 사용하여 논리적으로 동등한 개념의 그룹을 찾는 방법은 무엇입니까?

StackOverflow https://stackoverflow.com//questions/24057314

문제

실제로 저는 OWL API와 Java 프로그래밍을 사용하여 OWL2 언어에 정의된 온톨로지를 만듭니다.추론 엔진 Pellet을 사용하기 위해 프로젝트에 필요한 jar를 통합합니다.내 질문은 논리적으로 동등한 개념의 온톨로지 그룹을 어떻게 감지하는가입니다.여기에 제가 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 코드가 필요합니다.귀하의 도움에 감사드립니다.미리 감사드립니다

도움이 되었습니까?

해결책

OWLAPI에서는 다음의 모든 결과가 OWLReasoner 유형의 것 Node 그리고 NodeSet 동등한 엔터티 세트로 구성됩니다.

을 위한 OWLNamedIndividual, OWLReasoner::getSameIndividuals() 반환합니다 Node<OWLNamedIndividual> 개체라고 추론되는 모든 개인을 포함하는 개체 sameAs 서로.

클래스의 인스턴스를 요청하는 것도 가능합니다:OWLReasoner::getInstances() 반환합니다 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

노드 Resoner 인터페이스에는 리턴 방법이 포함되어 있습니다 NodeSet 사물.이것들은 세트입니다 Node 사물.노드에는 엔터티가 포함되어 있습니다.에 대한 Node<OWLClass> 클래스 중에서 노드의 각 클래스는 루트 온톨로지의 가져오기 폐쇄와 관련하여 노드의 다른 클래스와 동일합니다.에 대한 Node<OWLObjectProperty> 객체 속성 중 노드의 각 객체 속성은 루트 온톨로지의 가져오기 클로저와 관련하여 노드의 다른 객체 속성과 동일합니다.데이터 속성 노드의 경우 노드의 각 데이터 속성은 루트 온톨로지의 가져오기 폐쇄와 관련하여 노드의 다른 데이터 속성과 동일합니다.명명된 개인으로 구성된 노드의 경우, 노드의 각 개인은 루트 온톨로지의 가져오기 폐쇄와 관련하여 노드의 다른 개인과 동일합니다.

다른 팁

참고 :이 답변의 접근 방식은 Jena API가 사용되고 있음 (많은 코드가 질문의 원래 버전에 표시되지 않았습니다). < / P>

이것은 펠릿이 다른 API (예 : owlapi)와 함께 사용할 수 있고이 정보를 검색하는 방법은 다른 API (예 : owlapi)와 함께 사용될 수 있기 때문에이 정보를 검색 할 수 있으므로이 정보를 어떻게 사용할 수 있으므로이 정보를 사용하는 방법에 대한 질문이 있습니다. 지금까지 표시 한 코드는 Jena를 사용하는 것으로 보입니다. 여기에 고려해야 할 주요 접근법은 다음과 같습니다.

  • 모든 쌍의 동등한 클래스
    • 목록
  • 일부 특정 클래스의 경우 모든 동등한 클래스를 나열합니다

아래 코드는 둘 다를 수행하는 방법을 보여줍니다. 무한히 많은 사람들이 있기 때문에 all 등가의 클래스를 리스팅하는 것이 좋습니다. 예를 들어,

A ≡ ⊤ ⊤ ⊓ ≡ ≡ a ⊓ ⊓ ⊓ ⊤ ⊤ ⊤ ⊤ ⊤ ⊤

엄격하게 말하면, 그것들은 수업 표현식 입니다. 그 중 하나 이상이있을 수 있습니다. 예를 들어, 예를 들어 ≡ b, 정말로 하나의 클래스 가 있습니다. 그 수업을 나타내는 두 가지 클래스 표현식이 될 수 있습니다. 그것은 "어떤 숫자가 2와 같습니까?" 대답은 "단지 2"이며, 질문은 "어떤 산술 표현식은 가치 2가 있습니까?" 그 대답은 {2, 1 + 1, 2 × 1, 4/2, ...}입니다. 나는 펠릿이 당신을 알려줄 것으로 확신하지 못하기 때문에 나는 그것이 당신을 알려줄 것으로 기대하지만, 이미 온톨로지에 이미 존재하는 수업 표현을 찾을 것으로 기대하기 때문에 이것을 가리킨다. 

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

라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top