Debian Codegraph @

Source/Reasoner/Classifier/CIncrementalKPSetClassSubsumptionClassifierThread.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CIncrementalKPSetClassSubsumptionClassifierThread.h"
22
23 namespace Konclude {
24
25 namespace Reasoner {
26
27 namespace Classifier {
28
29
30
31 CIncrementalKPSetClassSubsumptionClassifierThread::CIncrementalKPSetClassSubsumptionClassifierThread(CReasonerManager *reasonerManager)
32 : COptimizedKPSetClassSubsumptionClassifierThread(reasonerManager) {
33
34 }
35
36
37 CIncrementalKPSetClassSubsumptionClassifierThread::~CIncrementalKPSetClassSubsumptionClassifierThread() {
38 }
39
40
41
42
43 void CIncrementalKPSetClassSubsumptionClassifierThread::readCalculationConfig(CCalculationConfigurationExtension *config) {
44 COptimizedKPSetClassSubsumptionClassifierThread::readCalculationConfig(config);
45
46 }
47
48
49 COptimizedKPSetClassOntologyClassificationItem* CIncrementalKPSetClassSubsumptionClassifierThread::createOntologyClassificationItem(CConcreteOntology *ontology, CConfigurationBase *config) {
50 return new CIncrementalKPSetClassOntologyClassificationItem(config,statistics);
51 }
52
53
54 CSubsumptionClassifierThread *CIncrementalKPSetClassSubsumptionClassifierThread::scheduleOntologyClassification(CConcreteOntology *ontology, CClassificationCalculationSupport *classificationSupport, CConfigurationBase *config) {
55
56
57 CTaxonomy *taxonomy = createEmptyTaxonomyForOntology(ontology,config);
58 CIncrementalKPSetClassOntologyClassificationItem* ontClassItem = (CIncrementalKPSetClassOntologyClassificationItem*)createOntologyClassificationItem(ontology,config);
59 ontClassItem->initTaxonomyConcepts(ontology,taxonomy);
60 ontItemList.append(ontClassItem);
61 processingOntItemList.append(ontClassItem);
62 ontItemHash.insert(ontology,ontClassItem);
63
64 readCalculationConfig(ontClassItem->getCalculationConfiguration());
65
66
67 // get previous classification result
68 COntologyIncrementalRevisionData* incOntData = ontology->getIncrementalRevisionData();
69 CConcreteOntology* prevClassifiedOnt = incOntData->getPreviousClassesClassifiedOntology();
70 bool reclassificationRequired = false;
71 CClassConceptClassification* prevClassification = nullptr;
72 if (prevClassifiedOnt) {
73 prevClassification = prevClassifiedOnt->getClassification()->getClassConceptClassification();
74 if (prevClassification) {
75 CIndividualDependenceTracking* prevDepIndiTracking = prevClassification->getDependentIndividualsTracking();
76 if (prevDepIndiTracking) {
77 CConcreteOntology* prevConsOnt = ontology;
78 do {
79 CConsistence* prevConsData = prevConsOnt->getConsistence();
80 if (prevConsData) {
81 if (prevDepIndiTracking->areIndividualsAffected(prevConsData->getConsistenceModelData())) {
82 reclassificationRequired = true;
83 }
84 }
85 if (prevConsOnt != prevClassifiedOnt) {
86 prevConsOnt = prevConsOnt->getIncrementalRevisionData()->getPreviousConsistentOntology();
87 }
88 } while (!reclassificationRequired && prevConsOnt && prevConsOnt != prevClassifiedOnt);
89 } else if (!prevClassification->isIndividualDependentTrackingSet()) {
90 reclassificationRequired = true;
91 }
92 } else {
93 reclassificationRequired = true;
94 }
95 } else {
96 reclassificationRequired = true;
97 }
98
99
100
101 if (!reclassificationRequired) {
102 ontClassItem->setPreviousHierarchyReused(true);
103 CIndividualDependenceTracking* prevDepIndiTracking = prevClassification->getDependentIndividualsTracking();
104 CTaxonomy* prevTaxonomy = prevClassification->getClassConceptTaxonomy();
105 if (prevTaxonomy) {
106
107 QHash<CConcept*,CHierarchyNode*>* prevConHierNodeHash = prevTaxonomy->getConceptHierarchyNodeHash();
108
109 for (QHash<CConcept*,CHierarchyNode*>::const_iterator it = prevConHierNodeHash->constBegin(), itEnd = prevConHierNodeHash->constEnd(); it != itEnd; ++it) {
110 CConcept* concept = it.key();
111 CHierarchyNode* prevHierNode = it.value();
112 ontClassItem->incPreviousReusedClassCalculationCount();
113 if (prevHierNode->isActive()) {
114 CHierarchyNode* hierNode = taxonomy->getHierarchyNode(concept,true);
115 QList<CConcept*>* eqConList = prevHierNode->getEquivalentConceptList();
116 if (eqConList->count() > 1 && hierNode->getEquivalentConceptList()->count() <= 1) {
117 for (QList<CConcept*>::const_iterator eqConIt = eqConList->constBegin(), eqConItEnd = eqConList->constEnd(); eqConIt != eqConItEnd; ++eqConIt) {
118 CConcept* eqConcept = *eqConIt;
119 if (eqConcept != concept) {
120 hierNode->addEquivalentConcept(eqConcept);
121 }
122 }
123 taxonomy->updateNodeEquivalences(hierNode);
124 }
125 }
126 }
127
128
129 for (QHash<CConcept*,CHierarchyNode*>::const_iterator it = prevConHierNodeHash->constBegin(), itEnd = prevConHierNodeHash->constEnd(); it != itEnd; ++it) {
130 CConcept* concept = it.key();
131 CHierarchyNode* prevHierNode = it.value();
132 if (prevHierNode->isActive()) {
133 CHierarchyNode* hierNode = taxonomy->getHierarchyNode(concept,true);
134 QSet<CHierarchyNode*>* prevPredSet = prevHierNode->getPredecessorNodeSet();
135 for (QSet<CHierarchyNode*>::const_iterator prevPredIt = prevPredSet->constBegin(), prevPredItEnd = prevPredSet->constEnd(); prevPredIt != prevPredItEnd; ++prevPredIt) {
136 CHierarchyNode* prevPredNode(*prevPredIt);
137 CHierarchyNode* predHierNode = taxonomy->getHierarchyNode(prevPredNode->getOneEquivalentConcept(),true);
138 hierNode->addPredecessorNode(predHierNode);
139 }
140 QSet<CHierarchyNode*>* prevParentSet = prevHierNode->getParentNodeSet();
141 for (QSet<CHierarchyNode*>::const_iterator prevParentIt = prevParentSet->constBegin(), prevParentItEnd = prevParentSet->constEnd(); prevParentIt != prevParentItEnd; ++prevParentIt) {
142 CHierarchyNode* prevParentNode(*prevParentIt);
143 CHierarchyNode* parentHierNode = taxonomy->getHierarchyNode(prevParentNode->getOneEquivalentConcept(),true);
144 hierNode->makeParent(parentHierNode);
145 }
146 }
147 }
148
149
150 CClassification* classification = ontology->getClassification();
151 if (classification) {
152 CClassConceptClassification* classConClassification = ontClassItem->getClassConceptClassification();
153 addClassificationStatistics(ontClassItem,classConClassification);
154 classConClassification->setClassConceptTaxonomy(taxonomy);
155 classification->setClassConceptClassification(classConClassification);
156 CClassificationStatisticsCollectionStrings* classifStatCollStrings = ontClassItem->getClassificationStatisticsCollectionStrings();
157 classConClassification->setClassificationStatistics(classifStatCollStrings);
158 if (prevDepIndiTracking) {
159 classConClassification->setDependentIndividualsTracking(prevDepIndiTracking->getCopiedIndividualDependencyTracking());
160 }
161 }
162
163
164 ontology->setConceptTaxonomy(taxonomy);
165 ontClassItem->setHasRemainingTests(false);
166 taxonomy->setTaxonomyComplete(true);
167
168 ontClassItem->submitTaxonomyConstructed();
169 ontClassItem->doClassifiedCallback();
170 LOG(INFO,getLogDomain(),logTr("Obtained classification of ontology '%1' by reusing previous class hierarchy.").arg(ontology->getTerminologyName()),getLogObject());
171 } else {
172 reclassificationRequired = true;
173 }
174 }
175
176
177
178 if (reclassificationRequired) {
179 if (CConfigDataReader::readConfigBoolean(ontClassItem->getCalculationConfiguration(),"Konclude.Calculation.Classification.IndividualDependenceTracking",true)) {
180 ontClassItem->setIndividualDependenceTrackingCollector(new CIndividualDependenceTrackingCollector());
181 }
182
183
184 CPartialPruningTaxonomy *parTax = dynamic_cast<CPartialPruningTaxonomy *>(taxonomy);
185 if (parTax) {
186 COntologyClassClassificationItem *ontClassItem = (COntologyClassClassificationItem*)ontItemHash.value(ontology);
187 parTax->createStatistics(ontClassItem->getClassifierStatistics());
188 }
189
190 tryReusePreviousClassesCalculations(ontClassItem,prevClassification);
191 createObviousSubsumptionSatisfiableTestingOrder(ontClassItem);
192
193 if (satTestedCount == totalToSatTestClassCount) {
194 satTestedCount = 0;
195 totalToSatTestClassCount = ontClassItem->getRemainingSatisfiableTestsCount();
196 classStartTime.start();
197 } else {
198 totalToSatTestClassCount += ontClassItem->getRemainingSatisfiableTestsCount();
199 }
200 ++mClassificationCount;
201 }
202 return this;
203 }
204
205
206 bool CIncrementalKPSetClassSubsumptionClassifierThread::tryReusePreviousClassesCalculations(CIncrementalKPSetClassOntologyClassificationItem *ontClassItem, CClassConceptClassification* prevClassConClassification) {
207 CIncrementalKPSetClassOntologyClassificationItem* prevIncKPClassItem = dynamic_cast<CIncrementalKPSetClassOntologyClassificationItem*>(prevClassConClassification);
208 while (prevIncKPClassItem && prevIncKPClassItem->getPreviousReusedClassClassification()) {
209 prevClassConClassification = prevIncKPClassItem->getPreviousReusedClassClassification();
210 prevIncKPClassItem = dynamic_cast<CIncrementalKPSetClassOntologyClassificationItem*>(prevClassConClassification);
211 }
212 COptimizedKPSetClassOntologyClassificationItem* prevKPClassOntItem = dynamic_cast<COptimizedKPSetClassOntologyClassificationItem*>(prevClassConClassification);
213 if (prevKPClassOntItem) {
214 QList<COptimizedKPSetClassTestingItem*>* prevConTestItemCont = prevKPClassOntItem->getConceptSatisfiableTestItemContainer();
215 for (QList<COptimizedKPSetClassTestingItem*>::const_iterator prevConItemIt = prevConTestItemCont->constBegin(), prevConItemItEnd = prevConTestItemCont->constEnd(); prevConItemIt != prevConItemItEnd; ++prevConItemIt) {
216 COptimizedKPSetClassTestingItem* prevConItem = (*prevConItemIt);
217 if (!prevConItem->hasIndividualDependenceTracked()) {
218 ontClassItem->incPreviousReusedClassCalculationCount();
219 COptimizedKPSetClassTestingItem* conItem = ontClassItem->getConceptSatisfiableTestItem(prevConItem->getTestingConcept(),true);
220 conItem->setSatisfiableTestedResult(prevConItem->getSatisfiableTestedResult());
221 conItem->setSatisfiableTested(true);
222 QSet<COptimizedKPSetClassTestingItem*>* prevSubsumerSet = prevConItem->getSubsumingConceptItemSet();
223 for (QSet<COptimizedKPSetClassTestingItem*>::const_iterator it = prevSubsumerSet->constBegin(), itEnd = prevSubsumerSet->constEnd(); it != itEnd; ++it) {
224 COptimizedKPSetClassTestingItem* prevSubsumerItem = (*it);
225 COptimizedKPSetClassTestingItem* subsumerConItem = ontClassItem->getConceptSatisfiableTestItem(prevSubsumerItem->getTestingConcept(),true);
226 conItem->addSubsumingConceptItem(subsumerConItem);
227 }
228 } else {
229 ontClassItem->incNewInitializedClassCalculationCount();
230 }
231 }
232 return true;
233 }
234 COptimizedSubClassOntologyClassificationItem* prevSubClassOntItem = dynamic_cast<COptimizedSubClassOntologyClassificationItem*>(prevClassConClassification);
235 if (prevSubClassOntItem) {
236 QList<COptimizedSubClassSatisfiableTestingItem*>* prevConTestItemCont = prevSubClassOntItem->getConceptSatisfiableTestItemContainer();
237 for (QList<COptimizedSubClassSatisfiableTestingItem*>::const_iterator prevConItemIt = prevConTestItemCont->constBegin(), prevConItemItEnd = prevConTestItemCont->constEnd(); prevConItemIt != prevConItemItEnd; ++prevConItemIt) {
238 COptimizedSubClassSatisfiableTestingItem* prevConItem = (*prevConItemIt);
239 if (!prevConItem->hasIndividualDependenceTracked()) {
240 ontClassItem->incPreviousReusedClassCalculationCount();
241 COptimizedKPSetClassTestingItem* conItem = ontClassItem->getConceptSatisfiableTestItem(prevConItem->getSatisfiableConcept(),true);
242 conItem->setSatisfiableTestedResult(prevConItem->getSatisfiableTestedResult());
243 conItem->setSatisfiableTested(true);
244 QSet<COptimizedSubClassSatisfiableTestingItem*>* prevSubsumerSet = prevConItem->getSubsumingConceptItemSet();
245 for (QSet<COptimizedSubClassSatisfiableTestingItem*>::const_iterator it = prevSubsumerSet->constBegin(), itEnd = prevSubsumerSet->constEnd(); it != itEnd; ++it) {
246 COptimizedSubClassSatisfiableTestingItem* prevSubsumerItem = (*it);
247 COptimizedKPSetClassTestingItem* subsumerConItem = ontClassItem->getConceptSatisfiableTestItem(prevSubsumerItem->getSatisfiableConcept(),true);
248 conItem->addSubsumingConceptItem(subsumerConItem);
249 }
250 } else {
251 ontClassItem->incNewInitializedClassCalculationCount();
252 }
253 }
254 return true;
255 }
256 return false;
257 }
258
259
260 bool CIncrementalKPSetClassSubsumptionClassifierThread::addClassificationStatistics(COntologyClassClassificationItem *ontClassItem, CClassConceptClassification* classConClassification) {
261 CClassificationStatisticsCollectionStrings* classifStatCollStrings = ontClassItem->getClassificationStatisticsCollectionStrings();
262 CClassifierStatistics* classifierStats = ontClassItem->getClassifierStatistics();
263 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-total-satisfiable-test-count",classifierStats->getTotalSatisfiableCount());
264 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-satisfiable-tested-count",classifierStats->getTestedSatisfiableCount());
265 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-satisfiable-pseudo-model-merged-tested-count",classifierStats->getPseudoModelMergedTestedSatisfiableCount());
266 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-satisfiable-derivation-tested-count",classifierStats->getDerivatedTestedSatisfiableCount());
267 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-satisfiable-calculated-tested-count",classifierStats->getCalculatedTestedSatisfiableCount());
268 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-satisfiable-pruned-tested-count",classifierStats->getPrunedTestedSatisfiableCount());
269 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-satisfiable-told-tested-count",classifierStats->getToldSatisfiableCount()-classifierStats->getCalculatedTestedSatisfiableCount());
270 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-total-subsumption-test-count",classifierStats->getTotalSatisfiableCount()*(classifierStats->getTotalSatisfiableCount()-1));
271 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-tested-count",classifierStats->getTestedSubsumptionCount());
272 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-pseudo-model-merged-tested-count",classifierStats->getPseudoModelMergedTestedSubsumptionCount());
273 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-subclass-tested-count",classifierStats->getSubclassTestedSubsumptionCount());
274 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-subclass-identifier-occur-tested-count",classifierStats->getSubclassIdentifierOccurTestedSubsumptionCount());
275 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-derivation-tested-count",classifierStats->getDerivatedTestedSubsumptionCount());
276 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-calculated-tested-count",classifierStats->getCalculatedTestedSubsumptionCount());
277 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-pruned-tested-count",classifierStats->getPrunedTestedSubsumptionCount());
278 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-subsumption-told-tested-count",classifierStats->getToldSubsumptionCount()-classifierStats->getCalculatedTestedSubsumptionCount());
279 classifStatCollStrings->addProcessingStatistics("incremental-class-classification-time",ontClassItem->getInitializationTime()->elapsed());
280
281 COptimizedKPSetClassOntologyClassificationItem *optKPSetClassificationItem = dynamic_cast<COptimizedKPSetClassOntologyClassificationItem*>(ontClassItem);
282 if (optKPSetClassificationItem) {
283 addIndividualDependencyTrackingStatistics(optKPSetClassificationItem,"incremental-class-classification");
284 }
285
286 COntologyProcessingStatistics* ontProcStats = ontClassItem->getClassificationProcessingStep()->getProcessingStatistics(true);
287 ontProcStats->setProcessingCountStatisticValue("incremental-class-classification-time",ontClassItem->getInitializationTime()->elapsed());
288
289 CIncrementalKPSetClassOntologyClassificationItem* incOntClassItem = dynamic_cast<CIncrementalKPSetClassOntologyClassificationItem*>(ontClassItem);
290 if (incOntClassItem) {
291 ontProcStats->setProcessingCountStatisticValue("incremental-class-classification-previous-hierarchy-reused-count",incOntClassItem->isPreviousHierarchyReused());
292 ontProcStats->setProcessingCountStatisticValue("incremental-class-classification-previously-reused-class-calculation-count",incOntClassItem->getPreviousReusedClassCalculationCount());
293 ontProcStats->setProcessingCountStatisticValue("incremental-class-classification-newly-initialized-class-calculation-count",incOntClassItem->getNewInitializedClassCalculationCount());
294 }
295 return true;
296 }
297
298
299 }; // end namespace Classifier
300
301 }; // end namespace Reasoner
302
303 }; // end namespace Konclude