Несоответствие и выполнимость онтологии OWL в Java с использованием рассуждения Пелле - PullRequest
Новая
       72

Несоответствие и выполнимость онтологии OWL в Java с использованием рассуждения Пелле

0 голосов
/ 20 апреля 2020

Я пытаюсь понять, является ли онтология последовательной или нет. Онтология может быть последовательной, но, тем не менее, она может иметь некоторые неудовлетворительные классы. Давайте назовем это Случай A .

Но моя проблема в том, что онтология не может пройти тест на согласованность, т. Е. Она не соответствует ( Случай B ). Моя проблема даже в том, что я не могу получить неутолимые классы онтологии в случае B .

Моя конечная цель - обработать неудовлетворительные классы, чтобы внести в них некоторые изменения и внести несовместимые онтологии в согласованные. Таким образом, я могу достичь своей цели в случае A (у меня есть доступ к неудовлетворительным классам), я обрабатываю их и пересматриваю некоторые из них. Но теперь, что я могу сделать для Дело B ?

Следующий код показывает эти два случая. 

   OWLReasonerFactory reasonerFactory = new PelletReasonerFactory();
   OWLReasoner reasoner = reasonerFactory.createNonBufferingReasoner(myOntology);

    if (reasoner.isConsistent()) {
        if (reasoner.getUnsatisfiableClasses().getEntitiesMinusBottom().size() > 0) {
            System.out.println("ontology is consistent but has unsatisfiable classes! FAILED");
                    // CASE A
        } else {
            System.out.println("ontology is consistent and safe without any unsatisfiable classes! PASSED");
        }

    } else {
        System.out.println("ontology is inconsistent!FAILED");
                // CASE B
    }

Для Дело B, Что я могу делать? В здесь написано:

Если вы хотите найти неудовлетворительные классы, вам просто нужно вызвать метод isSatisfiable для всех классов: reasoner.isSatisfiable(className);

Я поместил следующий код в Дело B : 

    Iterator<OWLClass> cAll = myOntology.getClassesInSignature().iterator();
    while (cAll.hasNext()) {
            OWLClass c = cAll.next();
            if (!reasoner.isSatisfiable(c)) {
                System.out.println("class " + c + "is not satisfibale");
            }
    }

, но я получаю сообщение об ошибке: 

Exception in thread "main" org.semanticweb.owlapi.reasoner.InconsistentOntologyException: Inconsistent ontology
    at com.clarkparsia.pellet.owlapiv3.PelletReasoner.convert(PelletReasoner.java:360)
    at com.clarkparsia.pellet.owlapiv3.PelletReasoner.isSatisfiable(PelletReasoner.java:890)

Так как я могу обработать онтологию в Case B ?

Обновление

Основано на комментариях @ Игнацио, в коде моего вопроса, вместо // CASE B, я вызываю эту новую функцию: 

public static void run(OWLOntology myOnt) {
    // save the Tbox and Abox of the original ontology
    Set<OWLAxiom> originalTboxAxioms = myOnt.getTBoxAxioms(true);
    Set<OWLAxiom> originalAboxAxioms = myOnt.getABoxAxioms(true);

    // create new empty ontology
    String name = "local_path//name.owl";
    OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
    File fileM = new File(name);
    OWLOntology newOntology = null;

    try {
        newOntology = manager.createOntology(IRI.create(fileM));
    } catch (OWLOntologyCreationException e) {
        e.printStackTrace();
    }

    // add only Tboxes from the orginal ontology to the new one
    manager.addAxioms(newOntology, originalTboxAxioms);

    // checking the consistency of the new ontology which contain only tbox
    OWLReasonerFactory reasonerFactory = new PelletReasonerFactory();
    Configuration configuration = new Configuration();
    configuration.throwInconsistentOntologyException = false;
    OWLReasoner reasoner = reasonerFactory.createNonBufferingReasoner(newOntology, configuration);

    if (reasoner.isConsistent()) {
       Set<OWLClass> unSat = reasoner.getUnsatisfiableClasses().getEntitiesMinusBottom();        
       if (unSat.size() > 0) {
            Iterator<OWLClass> unClassList = unSat.iterator();

            Set<OWLClass> listOfUnsatisfiableClasses = new HashSet<OWLClass>();
            while (unClassList.hasNext()) {
                /*
                 * if the unsatisfiable class appear in the original Abox,
                 * we mark it as an unsatisfiable class
                 */
                OWLClass myClass = unClassList.next();
                Iterator<OWLAxiom> iter = originalAboxAxioms.iterator();
                    while (iter.hasNext()){
                        OWLAxiom ax = iter.next();
                        if (ax.getClassesInSignature().contains(myClass)){
                            listOfUnsatisfiableClasses.add(myClass);    
                        }
                    }
            }
            System.out.println("number of unsatisfiable classes: " + listOfUnsatisfiableClasses.size());
        }
    }
    System.out.println("The ontology is inconsistent but does not have any unsatisfiable classes!!!!!");
}

Даже с этой новой функцией невозможно найти неудовлетворительные calsses!

Я также попробовал код в здесь , который опубликовал @Ignazio. В приведенном примере этот код будет запущен через несколько секунд, но для моей небольшой противоречивой онтологии даже через 1 день результат не будет напечатан.

Больше идей о том, как получить неудовлетворительные классы наряду с их комплектами обоснования?

1 Ответ

0 голосов
/ 21 апреля 2020

Несоответствующая онтология означает, что есть экземпляры неудовлетворительных классов или есть два или более классов, которые объявлены как непересекающиеся.

(Возможно, могут быть лица, объявленные как тип owl: Ничего, но это легко обнаружить и, вероятно, ошибку.)

Чтобы выяснить, зависит ли несоответствие от неудовлетворительных классов или нет, вы можете попробовать разделить abox и tbox - затем отметьте только tbox. Вы можете перечислить типы аксиом, которые принадлежат tbox, с помощью вспомогательных методов в AxiomType.

Обновление: Глядя на код, нужно исправить несколько вещей: 

    if (reasoner.getUnsatisfiableClasses().getEntitiesMinusBottom().size() > 0) {
        ^^^^^^^^^^^^^^ you're calling reasoner.getUnsatisfiableClasses() twice,
                       forcing the reasoner to do more work than necessary.
                       Store this set in a local variable, or skip the size check
                       (if the set is empty, the iterator will be empty
                       and you'll skip the while anyway.
      Iterator<OWLClass> unClassList = reasoner.getUnsatisfiableClasses().getEntitiesMinusBottom().iterator();


        Set<OWLClass> listOfUnsatisfiableClasses = new HashSet<OWLClass>();
        while (unClassList.hasNext()) {
            /*
             * if the unsatisfiable class appear in the original Abox,
             * we mark it as an unsatisfiable class
             */
            OWLClass myClass = unClassList.next();
            if (originalAboxAxioms.contains(myClass))
                listOfUnsatisfiableClasses.add(myClass);
            ^^^^^^ this code is not doing what the comment is saying.
                   originalAboxAxioms contains abox axioms, not classes,
                   so you'll never get true as a result of this lookup.
                   Also, the classes will necessarily be part of the ontology,
                   so you can skip this altogether.
        }
        System.out.println("number of unsatisfiable classes: " + listOfUnsatisfiableClasses.size());
    }
...