/* * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. * * This file is part of the reasoning system Konclude. * For details and support, see . * * Konclude is free software: you can redistribute it and/or modify * it under the terms of version 3 of the GNU Lesser General Public * License (LGPLv3) as published by the Free Software Foundation. * * Konclude is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU (Lesser) General Public License for more details. * * You should have received a copy of the GNU (Lesser) General Public * License along with Konclude. If not, see . * */ #include "CIncrementalKPSetClassSubsumptionClassifierThread.h" namespace Konclude { namespace Reasoner { namespace Classifier { CIncrementalKPSetClassSubsumptionClassifierThread::CIncrementalKPSetClassSubsumptionClassifierThread(CReasonerManager *reasonerManager) : COptimizedKPSetClassSubsumptionClassifierThread(reasonerManager) { } CIncrementalKPSetClassSubsumptionClassifierThread::~CIncrementalKPSetClassSubsumptionClassifierThread() { } void CIncrementalKPSetClassSubsumptionClassifierThread::readCalculationConfig(CCalculationConfigurationExtension *config) { COptimizedKPSetClassSubsumptionClassifierThread::readCalculationConfig(config); } COptimizedKPSetClassOntologyClassificationItem* CIncrementalKPSetClassSubsumptionClassifierThread::createOntologyClassificationItem(CConcreteOntology *ontology, CConfigurationBase *config) { return new CIncrementalKPSetClassOntologyClassificationItem(config,statistics); } CSubsumptionClassifierThread *CIncrementalKPSetClassSubsumptionClassifierThread::scheduleOntologyClassification(CConcreteOntology *ontology, CClassificationCalculationSupport *classificationSupport, CConfigurationBase *config) { CTaxonomy *taxonomy = createEmptyTaxonomyForOntology(ontology,config); CIncrementalKPSetClassOntologyClassificationItem* ontClassItem = (CIncrementalKPSetClassOntologyClassificationItem*)createOntologyClassificationItem(ontology,config); ontClassItem->initTaxonomyConcepts(ontology,taxonomy); ontItemList.append(ontClassItem); processingOntItemList.append(ontClassItem); ontItemHash.insert(ontology,ontClassItem); readCalculationConfig(ontClassItem->getCalculationConfiguration()); // get previous classification result COntologyIncrementalRevisionData* incOntData = ontology->getIncrementalRevisionData(); CConcreteOntology* prevClassifiedOnt = incOntData->getPreviousClassesClassifiedOntology(); bool reclassificationRequired = false; CClassConceptClassification* prevClassification = nullptr; if (prevClassifiedOnt) { prevClassification = prevClassifiedOnt->getClassification()->getClassConceptClassification(); if (prevClassification) { CIndividualDependenceTracking* prevDepIndiTracking = prevClassification->getDependentIndividualsTracking(); if (prevDepIndiTracking) { CConcreteOntology* prevConsOnt = ontology; do { CConsistence* prevConsData = prevConsOnt->getConsistence(); if (prevConsData) { if (prevDepIndiTracking->areIndividualsAffected(prevConsData->getConsistenceModelData())) { reclassificationRequired = true; } } if (prevConsOnt != prevClassifiedOnt) { prevConsOnt = prevConsOnt->getIncrementalRevisionData()->getPreviousConsistentOntology(); } } while (!reclassificationRequired && prevConsOnt && prevConsOnt != prevClassifiedOnt); } else if (!prevClassification->isIndividualDependentTrackingSet()) { reclassificationRequired = true; } } else { reclassificationRequired = true; } } else { reclassificationRequired = true; } if (!reclassificationRequired) { ontClassItem->setPreviousHierarchyReused(true); CIndividualDependenceTracking* prevDepIndiTracking = prevClassification->getDependentIndividualsTracking(); CTaxonomy* prevTaxonomy = prevClassification->getClassConceptTaxonomy(); if (prevTaxonomy) { QHash* prevConHierNodeHash = prevTaxonomy->getConceptHierarchyNodeHash(); for (QHash::const_iterator it = prevConHierNodeHash->constBegin(), itEnd = prevConHierNodeHash->constEnd(); it != itEnd; ++it) { CConcept* concept = it.key(); CHierarchyNode* prevHierNode = it.value(); ontClassItem->incPreviousReusedClassCalculationCount(); if (prevHierNode->isActive()) { CHierarchyNode* hierNode = taxonomy->getHierarchyNode(concept,true); QList* eqConList = prevHierNode->getEquivalentConceptList(); if (eqConList->count() > 1 && hierNode->getEquivalentConceptList()->count() <= 1) { for (QList::const_iterator eqConIt = eqConList->constBegin(), eqConItEnd = eqConList->constEnd(); eqConIt != eqConItEnd; ++eqConIt) { CConcept* eqConcept = *eqConIt; if (eqConcept != concept) { hierNode->addEquivalentConcept(eqConcept); } } taxonomy->updateNodeEquivalences(hierNode); } } } for (QHash::const_iterator it = prevConHierNodeHash->constBegin(), itEnd = prevConHierNodeHash->constEnd(); it != itEnd; ++it) { CConcept* concept = it.key(); CHierarchyNode* prevHierNode = it.value(); if (prevHierNode->isActive()) { CHierarchyNode* hierNode = taxonomy->getHierarchyNode(concept,true); QSet* prevPredSet = prevHierNode->getPredecessorNodeSet(); for (QSet::const_iterator prevPredIt = prevPredSet->constBegin(), prevPredItEnd = prevPredSet->constEnd(); prevPredIt != prevPredItEnd; ++prevPredIt) { CHierarchyNode* prevPredNode(*prevPredIt); CHierarchyNode* predHierNode = taxonomy->getHierarchyNode(prevPredNode->getOneEquivalentConcept(),true); hierNode->addPredecessorNode(predHierNode); } QSet* prevParentSet = prevHierNode->getParentNodeSet(); for (QSet::const_iterator prevParentIt = prevParentSet->constBegin(), prevParentItEnd = prevParentSet->constEnd(); prevParentIt != prevParentItEnd; ++prevParentIt) { CHierarchyNode* prevParentNode(*prevParentIt); CHierarchyNode* parentHierNode = taxonomy->getHierarchyNode(prevParentNode->getOneEquivalentConcept(),true); hierNode->makeParent(parentHierNode); } } } CClassification* classification = ontology->getClassification(); if (classification) { CClassConceptClassification* classConClassification = ontClassItem->getClassConceptClassification(); addClassificationStatistics(ontClassItem,classConClassification); classConClassification->setClassConceptTaxonomy(taxonomy); classification->setClassConceptClassification(classConClassification); CClassificationStatisticsCollectionStrings* classifStatCollStrings = ontClassItem->getClassificationStatisticsCollectionStrings(); classConClassification->setClassificationStatistics(classifStatCollStrings); if (prevDepIndiTracking) { classConClassification->setDependentIndividualsTracking(prevDepIndiTracking->getCopiedIndividualDependencyTracking()); } } ontology->setConceptTaxonomy(taxonomy); ontClassItem->setHasRemainingTests(false); taxonomy->setTaxonomyComplete(true); ontClassItem->submitTaxonomyConstructed(); ontClassItem->doClassifiedCallback(); LOG(INFO,getLogDomain(),logTr("Obtained classification of ontology '%1' by reusing previous class hierarchy.").arg(ontology->getTerminologyName()),getLogObject()); } else { reclassificationRequired = true; } } if (reclassificationRequired) { if (CConfigDataReader::readConfigBoolean(ontClassItem->getCalculationConfiguration(),"Konclude.Calculation.Classification.IndividualDependenceTracking",true)) { ontClassItem->setIndividualDependenceTrackingCollector(new CIndividualDependenceTrackingCollector()); } CPartialPruningTaxonomy *parTax = dynamic_cast(taxonomy); if (parTax) { COntologyClassClassificationItem *ontClassItem = (COntologyClassClassificationItem*)ontItemHash.value(ontology); parTax->createStatistics(ontClassItem->getClassifierStatistics()); } tryReusePreviousClassesCalculations(ontClassItem,prevClassification); createObviousSubsumptionSatisfiableTestingOrder(ontClassItem); if (satTestedCount == totalToSatTestClassCount) { satTestedCount = 0; totalToSatTestClassCount = ontClassItem->getRemainingSatisfiableTestsCount(); classStartTime.start(); } else { totalToSatTestClassCount += ontClassItem->getRemainingSatisfiableTestsCount(); } ++mClassificationCount; } return this; } bool CIncrementalKPSetClassSubsumptionClassifierThread::tryReusePreviousClassesCalculations(CIncrementalKPSetClassOntologyClassificationItem *ontClassItem, CClassConceptClassification* prevClassConClassification) { CIncrementalKPSetClassOntologyClassificationItem* prevIncKPClassItem = dynamic_cast(prevClassConClassification); while (prevIncKPClassItem && prevIncKPClassItem->getPreviousReusedClassClassification()) { prevClassConClassification = prevIncKPClassItem->getPreviousReusedClassClassification(); prevIncKPClassItem = dynamic_cast(prevClassConClassification); } COptimizedKPSetClassOntologyClassificationItem* prevKPClassOntItem = dynamic_cast(prevClassConClassification); if (prevKPClassOntItem) { QList* prevConTestItemCont = prevKPClassOntItem->getConceptSatisfiableTestItemContainer(); for (QList::const_iterator prevConItemIt = prevConTestItemCont->constBegin(), prevConItemItEnd = prevConTestItemCont->constEnd(); prevConItemIt != prevConItemItEnd; ++prevConItemIt) { COptimizedKPSetClassTestingItem* prevConItem = (*prevConItemIt); if (!prevConItem->hasIndividualDependenceTracked()) { ontClassItem->incPreviousReusedClassCalculationCount(); COptimizedKPSetClassTestingItem* conItem = ontClassItem->getConceptSatisfiableTestItem(prevConItem->getTestingConcept(),true); conItem->setSatisfiableTestedResult(prevConItem->getSatisfiableTestedResult()); conItem->setSatisfiableTested(true); QSet* prevSubsumerSet = prevConItem->getSubsumingConceptItemSet(); for (QSet::const_iterator it = prevSubsumerSet->constBegin(), itEnd = prevSubsumerSet->constEnd(); it != itEnd; ++it) { COptimizedKPSetClassTestingItem* prevSubsumerItem = (*it); COptimizedKPSetClassTestingItem* subsumerConItem = ontClassItem->getConceptSatisfiableTestItem(prevSubsumerItem->getTestingConcept(),true); conItem->addSubsumingConceptItem(subsumerConItem); } } else { ontClassItem->incNewInitializedClassCalculationCount(); } } return true; } COptimizedSubClassOntologyClassificationItem* prevSubClassOntItem = dynamic_cast(prevClassConClassification); if (prevSubClassOntItem) { QList* prevConTestItemCont = prevSubClassOntItem->getConceptSatisfiableTestItemContainer(); for (QList::const_iterator prevConItemIt = prevConTestItemCont->constBegin(), prevConItemItEnd = prevConTestItemCont->constEnd(); prevConItemIt != prevConItemItEnd; ++prevConItemIt) { COptimizedSubClassSatisfiableTestingItem* prevConItem = (*prevConItemIt); if (!prevConItem->hasIndividualDependenceTracked()) { ontClassItem->incPreviousReusedClassCalculationCount(); COptimizedKPSetClassTestingItem* conItem = ontClassItem->getConceptSatisfiableTestItem(prevConItem->getSatisfiableConcept(),true); conItem->setSatisfiableTestedResult(prevConItem->getSatisfiableTestedResult()); conItem->setSatisfiableTested(true); QSet* prevSubsumerSet = prevConItem->getSubsumingConceptItemSet(); for (QSet::const_iterator it = prevSubsumerSet->constBegin(), itEnd = prevSubsumerSet->constEnd(); it != itEnd; ++it) { COptimizedSubClassSatisfiableTestingItem* prevSubsumerItem = (*it); COptimizedKPSetClassTestingItem* subsumerConItem = ontClassItem->getConceptSatisfiableTestItem(prevSubsumerItem->getSatisfiableConcept(),true); conItem->addSubsumingConceptItem(subsumerConItem); } } else { ontClassItem->incNewInitializedClassCalculationCount(); } } return true; } return false; } bool CIncrementalKPSetClassSubsumptionClassifierThread::addClassificationStatistics(COntologyClassClassificationItem *ontClassItem, CClassConceptClassification* classConClassification) { CClassificationStatisticsCollectionStrings* classifStatCollStrings = ontClassItem->getClassificationStatisticsCollectionStrings(); CClassifierStatistics* classifierStats = ontClassItem->getClassifierStatistics(); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-total-satisfiable-test-count",classifierStats->getTotalSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-satisfiable-tested-count",classifierStats->getTestedSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-satisfiable-pseudo-model-merged-tested-count",classifierStats->getPseudoModelMergedTestedSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-satisfiable-derivation-tested-count",classifierStats->getDerivatedTestedSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-satisfiable-calculated-tested-count",classifierStats->getCalculatedTestedSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-satisfiable-pruned-tested-count",classifierStats->getPrunedTestedSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-satisfiable-told-tested-count",classifierStats->getToldSatisfiableCount()-classifierStats->getCalculatedTestedSatisfiableCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-total-subsumption-test-count",classifierStats->getTotalSatisfiableCount()*(classifierStats->getTotalSatisfiableCount()-1)); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-tested-count",classifierStats->getTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-pseudo-model-merged-tested-count",classifierStats->getPseudoModelMergedTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-subclass-tested-count",classifierStats->getSubclassTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-subclass-identifier-occur-tested-count",classifierStats->getSubclassIdentifierOccurTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-derivation-tested-count",classifierStats->getDerivatedTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-calculated-tested-count",classifierStats->getCalculatedTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-pruned-tested-count",classifierStats->getPrunedTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-told-tested-count",classifierStats->getToldSubsumptionCount()-classifierStats->getCalculatedTestedSubsumptionCount()); classifStatCollStrings->addProcessingStatistics("incremental-class-classification-time",ontClassItem->getInitializationTime()->elapsed()); COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem = dynamic_cast(ontClassItem); if (optKPSetClassificationItem) { addIndividualDependencyTrackingStatistics(optKPSetClassificationItem,"incremental-class-classification"); } COntologyProcessingStatistics* ontProcStats = ontClassItem->getClassificationProcessingStep()->getProcessingStatistics(true); ontProcStats->setProcessingCountStatisticValue("incremental-class-classification-time",ontClassItem->getInitializationTime()->elapsed()); CIncrementalKPSetClassOntologyClassificationItem* incOntClassItem = dynamic_cast(ontClassItem); if (incOntClassItem) { ontProcStats->setProcessingCountStatisticValue("incremental-class-classification-previous-hierarchy-reused-count",incOntClassItem->isPreviousHierarchyReused()); ontProcStats->setProcessingCountStatisticValue("incremental-class-classification-previously-reused-class-calculation-count",incOntClassItem->getPreviousReusedClassCalculationCount()); ontProcStats->setProcessingCountStatisticValue("incremental-class-classification-newly-initialized-class-calculation-count",incOntClassItem->getNewInitializedClassCalculationCount()); } return true; } }; // end namespace Classifier }; // end namespace Reasoner }; // end namespace Konclude