Menu
▾
▴
[DL-Learner SVN] SF.net SVN: dl-learner: [542] trunk/src/dl-learner/org/dllearner
|
From: <jen...@us...> - 2008-02-11 18:50:54
|
Revision: 542
http://dl-learner.svn.sourceforge.net/dl-learner/?rev=542&view=rev
Author: jenslehmann
Date: 2008-02-11 10:50:44 -0800 (Mon, 11 Feb 2008)
Log Message:
-----------
- refactored some DL elements to OWL elements
- enhanced datatype support
Modified Paths:
--------------
trunk/src/dl-learner/org/dllearner/algorithms/BruteForceLearner.java
trunk/src/dl-learner/org/dllearner/algorithms/RandomGuesser.java
trunk/src/dl-learner/org/dllearner/algorithms/gp/ADC.java
trunk/src/dl-learner/org/dllearner/algorithms/gp/GP.java
trunk/src/dl-learner/org/dllearner/algorithms/gp/GPUtilities.java
trunk/src/dl-learner/org/dllearner/algorithms/gp/Program.java
trunk/src/dl-learner/org/dllearner/algorithms/hybridgp/Psi.java
trunk/src/dl-learner/org/dllearner/algorithms/hybridgp/PsiDown.java
trunk/src/dl-learner/org/dllearner/algorithms/hybridgp/PsiUp.java
trunk/src/dl-learner/org/dllearner/algorithms/refexamples/ExampleBasedNode.java
trunk/src/dl-learner/org/dllearner/algorithms/refexamples/ExampleBasedROLComponent.java
trunk/src/dl-learner/org/dllearner/algorithms/refexamples/ExampleBasedROLearner.java
trunk/src/dl-learner/org/dllearner/algorithms/refinement/Node.java
trunk/src/dl-learner/org/dllearner/algorithms/refinement/ROLearner.java
trunk/src/dl-learner/org/dllearner/algorithms/refinement/RefinementOperator.java
trunk/src/dl-learner/org/dllearner/algorithms/refinement/RhoDown.java
trunk/src/dl-learner/org/dllearner/algorithms/refinement/SearchSpace.java
trunk/src/dl-learner/org/dllearner/cli/Start.java
trunk/src/dl-learner/org/dllearner/core/LearningAlgorithm.java
trunk/src/dl-learner/org/dllearner/core/LearningProblem.java
trunk/src/dl-learner/org/dllearner/core/Reasoner.java
trunk/src/dl-learner/org/dllearner/core/ReasonerComponent.java
trunk/src/dl-learner/org/dllearner/core/ReasoningService.java
trunk/src/dl-learner/org/dllearner/core/config/CommonConfigMappings.java
trunk/src/dl-learner/org/dllearner/core/owl/KB.java
trunk/src/dl-learner/org/dllearner/core/owl/Negation.java
trunk/src/dl-learner/org/dllearner/core/owl/SubsumptionHierarchy.java
trunk/src/dl-learner/org/dllearner/examples/Carcinogenesis.java
trunk/src/dl-learner/org/dllearner/gui/MiniGUI.java
trunk/src/dl-learner/org/dllearner/gui/WidgetPanelStringSet.java
trunk/src/dl-learner/org/dllearner/learningproblems/EvaluationCache.java
trunk/src/dl-learner/org/dllearner/learningproblems/PosNegDefinitionLP.java
trunk/src/dl-learner/org/dllearner/learningproblems/PosNegDefinitionLPStrict.java
trunk/src/dl-learner/org/dllearner/learningproblems/PosNegInclusionLP.java
trunk/src/dl-learner/org/dllearner/learningproblems/PosNegLP.java
trunk/src/dl-learner/org/dllearner/learningproblems/PosOnlyDefinitionLP.java
trunk/src/dl-learner/org/dllearner/learningproblems/PosOnlyInclusionLP.java
trunk/src/dl-learner/org/dllearner/learningproblems/RoleLearning.java
trunk/src/dl-learner/org/dllearner/parser/KBParser.java
trunk/src/dl-learner/org/dllearner/parser/kb.jj
trunk/src/dl-learner/org/dllearner/reasoning/DIGConverter.java
trunk/src/dl-learner/org/dllearner/reasoning/DIGReasoner.java
trunk/src/dl-learner/org/dllearner/reasoning/FastRetrieval.java
trunk/src/dl-learner/org/dllearner/reasoning/FastRetrievalReasoner.java
trunk/src/dl-learner/org/dllearner/reasoning/OWLAPIReasoner.java
trunk/src/dl-learner/org/dllearner/server/DLLearnerWS.java
trunk/src/dl-learner/org/dllearner/utilities/ConceptComparator.java
trunk/src/dl-learner/org/dllearner/utilities/ConceptTransformation.java
trunk/src/dl-learner/org/dllearner/utilities/CrossValidation.java
trunk/src/dl-learner/org/dllearner/utilities/Datastructures.java
trunk/src/dl-learner/org/dllearner/utilities/Helper.java
trunk/src/dl-learner/org/dllearner/utilities/OntologyClassRewriter.java
Added Paths:
-----------
trunk/src/dl-learner/org/dllearner/core/owl/ClassAssertionAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/Description.java
trunk/src/dl-learner/org/dllearner/core/owl/EquivalentClassesAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/FunctionalObjectPropertyAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/Intersection.java
trunk/src/dl-learner/org/dllearner/core/owl/InverseObjectPropertyAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/NamedClass.java
trunk/src/dl-learner/org/dllearner/core/owl/Nothing.java
trunk/src/dl-learner/org/dllearner/core/owl/ObjectAllRestriction.java
trunk/src/dl-learner/org/dllearner/core/owl/ObjectCardinalityRestriction.java
trunk/src/dl-learner/org/dllearner/core/owl/ObjectMaxCardinalityRestriction.java
trunk/src/dl-learner/org/dllearner/core/owl/ObjectMinCardinalityRestriction.java
trunk/src/dl-learner/org/dllearner/core/owl/ObjectPropertyHierarchy.java
trunk/src/dl-learner/org/dllearner/core/owl/ObjectQuantorRestriction.java
trunk/src/dl-learner/org/dllearner/core/owl/ObjectSomeRestriction.java
trunk/src/dl-learner/org/dllearner/core/owl/PropertyAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/SubClassAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/SubObjectPropertyAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/SymmetricObjectPropertyAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/Thing.java
trunk/src/dl-learner/org/dllearner/core/owl/TransitiveObjectPropertyAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/Union.java
Removed Paths:
-------------
trunk/src/dl-learner/org/dllearner/core/owl/All.java
trunk/src/dl-learner/org/dllearner/core/owl/AtomicConcept.java
trunk/src/dl-learner/org/dllearner/core/owl/Bottom.java
trunk/src/dl-learner/org/dllearner/core/owl/Concept.java
trunk/src/dl-learner/org/dllearner/core/owl/ConceptAssertion.java
trunk/src/dl-learner/org/dllearner/core/owl/Conjunction.java
trunk/src/dl-learner/org/dllearner/core/owl/Disjunction.java
trunk/src/dl-learner/org/dllearner/core/owl/Equality.java
trunk/src/dl-learner/org/dllearner/core/owl/Exists.java
trunk/src/dl-learner/org/dllearner/core/owl/FunctionalRoleAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/GreaterEqual.java
trunk/src/dl-learner/org/dllearner/core/owl/Inclusion.java
trunk/src/dl-learner/org/dllearner/core/owl/InverseRoleAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/LessEqual.java
trunk/src/dl-learner/org/dllearner/core/owl/MultiConjunction.java
trunk/src/dl-learner/org/dllearner/core/owl/MultiDisjunction.java
trunk/src/dl-learner/org/dllearner/core/owl/NumberRestriction.java
trunk/src/dl-learner/org/dllearner/core/owl/Quantification.java
trunk/src/dl-learner/org/dllearner/core/owl/RBoxAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/RoleHierarchy.java
trunk/src/dl-learner/org/dllearner/core/owl/SubRoleAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/SymmetricRoleAxiom.java
trunk/src/dl-learner/org/dllearner/core/owl/Top.java
trunk/src/dl-learner/org/dllearner/core/owl/TransitiveRoleAxiom.java
Modified: trunk/src/dl-learner/org/dllearner/algorithms/BruteForceLearner.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/algorithms/BruteForceLearner.java 2008-02-11 17:41:10 UTC (rev 541)
+++ trunk/src/dl-learner/org/dllearner/algorithms/BruteForceLearner.java 2008-02-11 18:50:44 UTC (rev 542)
@@ -35,16 +35,16 @@
import org.dllearner.core.config.ConfigOption;
import org.dllearner.core.config.IntegerConfigOption;
import org.dllearner.core.config.InvalidConfigOptionValueException;
-import org.dllearner.core.owl.All;
-import org.dllearner.core.owl.AtomicConcept;
-import org.dllearner.core.owl.Bottom;
-import org.dllearner.core.owl.Concept;
-import org.dllearner.core.owl.Conjunction;
-import org.dllearner.core.owl.Disjunction;
-import org.dllearner.core.owl.Exists;
+import org.dllearner.core.owl.Intersection;
+import org.dllearner.core.owl.Union;
+import org.dllearner.core.owl.ObjectAllRestriction;
+import org.dllearner.core.owl.NamedClass;
+import org.dllearner.core.owl.Nothing;
+import org.dllearner.core.owl.Description;
+import org.dllearner.core.owl.ObjectSomeRestriction;
import org.dllearner.core.owl.Negation;
import org.dllearner.core.owl.ObjectProperty;
-import org.dllearner.core.owl.Top;
+import org.dllearner.core.owl.Thing;
/**
* A brute force learning algorithm.
@@ -59,14 +59,14 @@
private LearningProblem learningProblem;
- private Concept bestDefinition;
+ private Description bestDefinition;
private Score bestScore;
private Integer maxLength = 7;
private String returnType;
// list of all generated concepts sorted by length
- private Map<Integer,List<Concept>> generatedDefinitions = new HashMap<Integer,List<Concept>>();
+ private Map<Integer,List<Description>> generatedDefinitions = new HashMap<Integer,List<Description>>();
public BruteForceLearner(LearningProblem learningProblem, ReasoningService rs) {
this.learningProblem = learningProblem;
@@ -159,12 +159,12 @@
long startTime = System.currentTimeMillis();
System.out.print("Testing definitions of length " + i + " ... ");
count = 0;
- for(Concept program : generatedDefinitions.get(i)) {
+ for(Description program : generatedDefinitions.get(i)) {
// if a return type is already given an appropriate tree is
// generated here
- Concept newRoot;
+ Description newRoot;
if(returnType != null) {
- newRoot = new Conjunction(new AtomicConcept(returnType),program);
+ newRoot = new Intersection(new NamedClass(returnType),program);
} else
newRoot = program;
@@ -189,19 +189,19 @@
}
private void generatePrograms(int length) {
- generatedDefinitions.put(length,new LinkedList<Concept>());
+ generatedDefinitions.put(length,new LinkedList<Description>());
if(length==1) {
- generatedDefinitions.get(1).add(new Top());
- generatedDefinitions.get(1).add(new Bottom());
- for(AtomicConcept atomicConcept : learningProblem.getReasoningService().getAtomicConcepts()) {
+ generatedDefinitions.get(1).add(new Thing());
+ generatedDefinitions.get(1).add(new Nothing());
+ for(NamedClass atomicConcept : learningProblem.getReasoningService().getAtomicConcepts()) {
generatedDefinitions.get(1).add(atomicConcept);
}
}
if(length>1) {
// negation
- for(Concept childNode : generatedDefinitions.get(length-1)) {
- Concept root = new Negation(childNode);
+ for(Description childNode : generatedDefinitions.get(length-1)) {
+ Description root = new Negation(childNode);
generatedDefinitions.get(length).add(root);
}
}
@@ -216,15 +216,15 @@
for(int z=1; z<=Math.floor(0.5*(length-1)); z++) {
// cycle through all concepts of length z (left subtree)
- for(Concept leftChild : generatedDefinitions.get(z)) {
+ for(Description leftChild : generatedDefinitions.get(z)) {
// cycle thorugh all concept of lengt "length-z-1" (right subtree)
- for(Concept rightChild : generatedDefinitions.get(length-z-1)) {
+ for(Description rightChild : generatedDefinitions.get(length-z-1)) {
// create concept tree
- Concept root;
+ Description root;
if(i==0) {
- root = new Disjunction(leftChild,rightChild);
+ root = new Union(leftChild,rightChild);
} else {
- root = new Conjunction(leftChild,rightChild);
+ root = new Intersection(leftChild,rightChild);
}
// Please not that we only set links here, i.e.:
@@ -250,12 +250,12 @@
}
// EXISTS and ALL
- for(Concept childNode : generatedDefinitions.get(length-2)) {
+ for(Description childNode : generatedDefinitions.get(length-2)) {
for(ObjectProperty atomicRole : learningProblem.getReasoningService().getAtomicRoles()) {
- Concept root1 = new Exists(atomicRole,childNode);
+ Description root1 = new ObjectSomeRestriction(atomicRole,childNode);
generatedDefinitions.get(length).add(root1);
- Concept root2 = new All(atomicRole,childNode);
+ Description root2 = new ObjectAllRestriction(atomicRole,childNode);
generatedDefinitions.get(length).add(root2);
}
}
@@ -268,7 +268,7 @@
}
@Override
- public Concept getBestSolution() {
+ public Description getBestSolution() {
return bestDefinition;
}
Modified: trunk/src/dl-learner/org/dllearner/algorithms/RandomGuesser.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/algorithms/RandomGuesser.java 2008-02-11 17:41:10 UTC (rev 541)
+++ trunk/src/dl-learner/org/dllearner/algorithms/RandomGuesser.java 2008-02-11 18:50:44 UTC (rev 542)
@@ -33,11 +33,11 @@
import org.dllearner.core.config.ConfigOption;
import org.dllearner.core.config.IntegerConfigOption;
import org.dllearner.core.config.InvalidConfigOptionValueException;
-import org.dllearner.core.owl.Concept;
+import org.dllearner.core.owl.Description;
public class RandomGuesser extends LearningAlgorithm {
- private Concept bestDefinition = null;
+ private Description bestDefinition = null;
private Score bestScore;
private double bestFitness = Double.NEGATIVE_INFINITY;
private LearningProblem learningProblem;
@@ -117,7 +117,7 @@
}
@Override
- public Concept getBestSolution() {
+ public Description getBestSolution() {
return bestDefinition;
}
Modified: trunk/src/dl-learner/org/dllearner/algorithms/gp/ADC.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/algorithms/gp/ADC.java 2008-02-11 17:41:10 UTC (rev 541)
+++ trunk/src/dl-learner/org/dllearner/algorithms/gp/ADC.java 2008-02-11 18:50:44 UTC (rev 542)
@@ -2,9 +2,9 @@
import java.util.Map;
-import org.dllearner.core.owl.Concept;
+import org.dllearner.core.owl.Description;
-public class ADC extends Concept {
+public class ADC extends Description {
/*
@Override
Modified: trunk/src/dl-learner/org/dllearner/algorithms/gp/GP.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/algorithms/gp/GP.java 2008-02-11 17:41:10 UTC (rev 541)
+++ trunk/src/dl-learner/org/dllearner/algorithms/gp/GP.java 2008-02-11 18:50:44 UTC (rev 542)
@@ -41,8 +41,8 @@
import org.dllearner.core.config.IntegerConfigOption;
import org.dllearner.core.config.InvalidConfigOptionValueException;
import org.dllearner.core.config.StringConfigOption;
-import org.dllearner.core.owl.Concept;
-import org.dllearner.core.owl.Top;
+import org.dllearner.core.owl.Description;
+import org.dllearner.core.owl.Thing;
import org.dllearner.learningproblems.PosNegLP;
import org.dllearner.utilities.Helper;
@@ -120,7 +120,7 @@
private long startTime;
private Score bestScore;
- private Concept bestConcept;
+ private Description bestConcept;
private PosNegLP learningProblem;
@@ -510,7 +510,7 @@
for(int i=0; i<numberOfIndividuals; i++) {
if(individuals[i].getTree().getLength()>maxConceptLength) {
System.out.println("Warning: GP produced concept longer then " + maxConceptLength + ". Replacing it with TOP.");
- individuals[i] = GPUtilities.createProgram(learningProblem, new Top());
+ individuals[i] = GPUtilities.createProgram(learningProblem, new Thing());
}
}
@@ -534,10 +534,10 @@
// der echten Score entsprechen muss, d.h. hier muss die
// Konzeptlänge mit einberechnet werden => deswegen werden
// neue Score-Objekte generiert
- Set<Entry<Concept,Score>> entrySet = psi.evalCache.entrySet();
- for(Entry<Concept,Score> entry : entrySet) {
+ Set<Entry<Description,Score>> entrySet = psi.evalCache.entrySet();
+ for(Entry<Description,Score> entry : entrySet) {
Score tmpScore = entry.getValue();
- Concept c = entry.getKey();
+ Description c = entry.getKey();
tmpScore = tmpScore.getModifiedLengthScore(c.getLength());
double tmpScoreValue = tmpScore.getScore();
if(tmpScoreValue>bestValue) {
@@ -820,7 +820,7 @@
private void printStatistics(Program fittestIndividual) {
// output statistics: best individual, average fitness, etc.
double averageFitness = getFitnessSum() / numberOfIndividuals;
- Concept n = fittestIndividual.getTree();
+ Description n = fittestIndividual.getTree();
int misClassifications = fittestIndividual.getScore().getNotCoveredPositives().size()
+ fittestIndividual.getScore().getCoveredNegatives().size();
@@ -947,7 +947,7 @@
}
@Override
- public Concept getBestSolution() {
+ public Description getBestSolution() {
// return fittestIndividual.getTree();
return bestConcept;
}
Modified: trunk/src/dl-learner/org/dllearner/algorithms/gp/GPUtilities.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/algorithms/gp/GPUtilities.java 2008-02-11 17:41:10 UTC (rev 541)
+++ trunk/src/dl-learner/org/dllearner/algorithms/gp/GPUtilities.java 2008-02-11 18:50:44 UTC (rev 542)
@@ -10,18 +10,18 @@
import org.dllearner.core.LearningProblem;
import org.dllearner.core.ReasoningMethodUnsupportedException;
import org.dllearner.core.Score;
-import org.dllearner.core.owl.All;
-import org.dllearner.core.owl.AtomicConcept;
-import org.dllearner.core.owl.Bottom;
-import org.dllearner.core.owl.Concept;
-import org.dllearner.core.owl.Exists;
+import org.dllearner.core.owl.ObjectAllRestriction;
+import org.dllearner.core.owl.NamedClass;
+import org.dllearner.core.owl.Nothing;
+import org.dllearner.core.owl.Description;
+import org.dllearner.core.owl.ObjectSomeRestriction;
import org.dllearner.core.owl.FlatABox;
import org.dllearner.core.owl.Individual;
-import org.dllearner.core.owl.MultiConjunction;
-import org.dllearner.core.owl.MultiDisjunction;
+import org.dllearner.core.owl.Intersection;
+import org.dllearner.core.owl.Union;
import org.dllearner.core.owl.Negation;
import org.dllearner.core.owl.ObjectProperty;
-import org.dllearner.core.owl.Top;
+import org.dllearner.core.owl.Thing;
import org.dllearner.learningproblems.PosNegDefinitionLPStrict;
import org.dllearner.learningproblems.ScoreThreeValued;
import org.dllearner.reasoning.FastRetrieval;
@@ -53,7 +53,7 @@
private static Random rand = new Random();
- private static Score calculateFitness(LearningProblem learningProblem, Concept hypothesis) {
+ private static Score calculateFitness(LearningProblem learningProblem, Description hypothesis) {
return calculateFitness(learningProblem, hypothesis, null);
}
@@ -62,8 +62,8 @@
// (macht aber nicht so viel Sinn, da man das bei richtigen Reasoning-Algorithmen
// ohnehin mit einer Erweiterung der Wissensbasis um die Inklusion Target SUBSETOF ReturnType
// erschlagen kann)
- private static Score calculateFitness(LearningProblem learningProblem, Concept hypothesis, Concept adc) {
- Concept extendedHypothesis;
+ private static Score calculateFitness(LearningProblem learningProblem, Description hypothesis, Description adc) {
+ Description extendedHypothesis;
// return type temporarily disabled
// => it is probably more appropriate to have the
@@ -122,11 +122,11 @@
return score;
}
- public static Program createProgram(LearningProblem learningProblem, Concept mainTree) {
+ public static Program createProgram(LearningProblem learningProblem, Description mainTree) {
return new Program(calculateFitness(learningProblem, mainTree), mainTree);
}
- private static Program createProgram(LearningProblem learningProblem, Concept mainTree, Concept adc) {
+ private static Program createProgram(LearningProblem learningProblem, Description mainTree, Description adc) {
return new Program(calculateFitness(learningProblem, mainTree,adc), mainTree, adc);
}
@@ -140,29 +140,29 @@
// TODO: hier kann man noch mehr Feinabstimmung machen, d.h.
// Mutation abh�ngig von Knotenanzahl
if(Math.random()<0.5) {
- Concept mainTree = mutation(learningProblem, p.getTree(),true);
- Concept adc = p.getAdc();
+ Description mainTree = mutation(learningProblem, p.getTree(),true);
+ Description adc = p.getAdc();
Score score = calculateFitness(learningProblem,mainTree,adc);
return new Program(score, mainTree, adc);
}
else {
- Concept mainTree = p.getTree();
- Concept adc = mutation(learningProblem, p.getAdc(),false);
+ Description mainTree = p.getTree();
+ Description adc = mutation(learningProblem, p.getAdc(),false);
Score score = calculateFitness(learningProblem,mainTree,adc);
return new Program(score, mainTree, adc);
}
} else {
- Concept tree = mutation(learningProblem, p.getTree(),false);
+ Description tree = mutation(learningProblem, p.getTree(),false);
Score score = calculateFitness(learningProblem, tree);
return new Program(score, tree);
}
}
- private static Concept mutation(LearningProblem learningProblem, Concept tree, boolean useADC) {
+ private static Description mutation(LearningProblem learningProblem, Description tree, boolean useADC) {
// auch bei Mutation muss darauf geachtet werden, dass
// Baum nicht modifiziert wird (sonst w�rde man automatisch auch
// andere "selected individuals" modifizieren)
- Concept t = (Concept) tree.clone();
+ Description t = (Description) tree.clone();
// bis auf Klon Mutation genau wie vorher
int size = t.getNumberOfNodes();
// TODO: auch Mutationen von Einzelknoten erlauben
@@ -182,10 +182,10 @@
*/
// neue Implementierung
int randNr = rand.nextInt(size) + 1;
- Concept st = t.getSubtree(randNr);
- Concept stParent = st.getParent();
+ Description st = t.getSubtree(randNr);
+ Description stParent = st.getParent();
stParent.getChildren().remove(st);
- Concept treeNew = createGrowRandomTree(learningProblem,3, useADC);
+ Description treeNew = createGrowRandomTree(learningProblem,3, useADC);
stParent.addChild(treeNew);
} else
// return createLeafNode(useADC);
@@ -193,11 +193,11 @@
return t;
}
- private static void swapSubtrees(Concept t1, Concept t2) {
+ private static void swapSubtrees(Description t1, Description t2) {
if (t1.getParent() != null && t2.getParent() != null) {
// handling children
- Concept t1Parent = t1.getParent();
- Concept t2Parent = t2.getParent();
+ Description t1Parent = t1.getParent();
+ Description t2Parent = t2.getParent();
// t1 is first child
if (t1Parent.getChild(0).equals(t1))
t1Parent.getChildren().add(0, t2);
@@ -230,7 +230,7 @@
public static Program[] crossover(LearningProblem learningProblem, Program p1, Program p2) {
crossover++;
if(p1.getAdc() != null) {
- Concept[] pt;
+ Description[] pt;
Program result[] = new Program[2];
// es wird entweder ADC oder Hauptbaum einem Crossover
@@ -246,7 +246,7 @@
}
return result;
} else {
- Concept[] pt = crossover(p1.getTree(), p2.getTree());
+ Description[] pt = crossover(p1.getTree(), p2.getTree());
Program result[] = new Program[2];
result[0] = createProgram(learningProblem,pt[0]);
result[1] = createProgram(learningProblem,pt[1]);
@@ -254,18 +254,18 @@
}
}
- private static Concept[] crossover(Concept tree1, Concept tree2) {
- Concept tree1cloned = (Concept) tree1.clone();
- Concept tree2cloned = (Concept) tree2.clone();
+ private static Description[] crossover(Description tree1, Description tree2) {
+ Description tree1cloned = (Description) tree1.clone();
+ Description tree2cloned = (Description) tree2.clone();
- Concept[] results = new Concept[2];
+ Description[] results = new Description[2];
int rand1 = rand.nextInt(tree1.getNumberOfNodes());
int rand2 = rand.nextInt(tree2.getNumberOfNodes());
- Concept t1 = tree1cloned.getSubtree(rand1);
- Concept t2 = tree2cloned.getSubtree(rand2);
+ Description t1 = tree1cloned.getSubtree(rand1);
+ Description t2 = tree2cloned.getSubtree(rand2);
if (t1.isRoot() && !t2.isRoot()) {
- Concept t2Parent = t2.getParent();
+ Description t2Parent = t2.getParent();
// t2 is first child
if (t2Parent.getChild(0).equals(t2))
t2Parent.getChildren().add(0, t1);
@@ -278,7 +278,7 @@
results[0] = t2;
results[1] = tree2cloned;
} else if (!t1.isRoot() && t2.isRoot()) {
- Concept t1Parent = t1.getParent();
+ Description t1Parent = t1.getParent();
// t2 is first child
if (t1Parent.getChild(0).equals(t1))
t1Parent.getChildren().add(0, t2);
@@ -314,7 +314,7 @@
// SortedSetTuple s = new SortedSetTuple(p.getScore().getDefPosSet(),p.getScore().getDefNegSet());
// Knoten kopieren, damit er sich nicht ver�ndert (es wird sonst der
// parent-Link ver�ndert)
- Concept treecloned = (Concept) p.getTree().clone();
+ Description treecloned = (Description) p.getTree().clone();
if(p.getAdc() != null)
return createProgram(learningProblem,hillClimbing(learningProblem,treecloned,(ScoreThreeValued)p.getScore()),p.getAdc());
else
@@ -326,11 +326,11 @@
// Alternativen zu speichern und dann ein Element zuf�llig auszuw�hlen,
// aber w�rde man das nicht machen, dann w�re das ein starker Bias
// zu z.B. Disjunktion (weil die als erstes getestet wird)
- private static Concept hillClimbing(LearningProblem learningProblem, Concept node, ScoreThreeValued score) {
+ private static Description hillClimbing(LearningProblem learningProblem, Description node, ScoreThreeValued score) {
SortedSetTuple<Individual> tuple = new SortedSetTuple<Individual>(score.getPosClassified(),score.getNegClassified());
SortedSetTuple<String> stringTuple = Helper.getStringTuple(tuple);
// FlatABox abox = FlatABox.getInstance();
- Concept returnNode = node;
+ Description returnNode = node;
// damit stellen wir sicher, dass nur Konzepte in die Auswahl
// genommen werden, die besser klassifizieren als das �bergebene
// Konzept (falls das nicht existiert, dann hill climbing = reproduction)
@@ -422,7 +422,7 @@
// returnNode.addChild(new AtomicConcept(name));
// returnNode.addChild(node);
// if(useMultiStructures)
- returnNode = new MultiDisjunction(new AtomicConcept(name),node);
+ returnNode = new Union(new NamedClass(name),node);
// else
// returnNode = new Disjunction(new AtomicConcept(name),node);
// wegen else if schlie�en sich die F�lle gegenseitig aus
@@ -432,19 +432,19 @@
// returnNode.addChild(new AtomicConcept(name));
// returnNode.addChild(node);
// if(useMultiStructures)
- returnNode = new MultiConjunction(new AtomicConcept(name),node);
+ returnNode = new Intersection(new NamedClass(name),node);
// else
// returnNode = new Conjunction(new AtomicConcept(name),node);
} else if(nr<sizeSum3) {
name = bestNeighbours.get(3).get(nr-sizeSum2);
// returnNode = new Exists(new AtomicRole(name));
// returnNode.addChild(node);
- returnNode = new Exists(new ObjectProperty(name),node);
+ returnNode = new ObjectSomeRestriction(new ObjectProperty(name),node);
} else {
name = bestNeighbours.get(4).get(nr-sizeSum3);
// returnNode = new All(new AtomicRole(name));
// returnNode.addChild(node);
- returnNode = new All(new ObjectProperty(name),node);
+ returnNode = new ObjectAllRestriction(new ObjectProperty(name),node);
}
return returnNode;
@@ -488,7 +488,7 @@
return returnMap;
}
- private static Concept pickTerminalSymbol(LearningProblem learningProblem, boolean useADC) {
+ private static Description pickTerminalSymbol(LearningProblem learningProblem, boolean useADC) {
// FlatABox abox = FlatABox.getInstance();
int nr;
int nrOfConcepts = learningProblem.getReasoningService().getAtomicConcepts().size();
@@ -501,16 +501,16 @@
nr = rand.nextInt(2+nrOfConcepts);
if(nr==0)
- return new Top();
+ return new Thing();
else if(nr==1)
- return new Bottom();
+ return new Nothing();
// die Zahl kann nur vorkommen, wenn ADC aktiviert ist
else if(nr==2+nrOfConcepts) {
// System.out.println("== ADC 2 ==");
return new ADC();
}
else
- return (AtomicConcept) learningProblem.getReasoningService().getAtomicConceptsList().get(nr-2).clone();
+ return (NamedClass) learningProblem.getReasoningService().getAtomicConceptsList().get(nr-2).clone();
}
// Funktion nach Umstelllung der Konstruktoren nicht mehr ben�tigt
@@ -628,7 +628,7 @@
return createProgram(learningProblem, createFullRandomTree(learningProblem, depth, false));
}
- private static Concept createFullRandomTree(LearningProblem learningProblem, int depth, boolean useADC) {
+ private static Description createFullRandomTree(LearningProblem learningProblem, int depth, boolean useADC) {
// FlatABox abox = FlatABox.getInstance();
int numberOfRoles = learningProblem.getReasoningService().getAtomicRoles().size(); // abox.roles.size();
@@ -637,26 +637,26 @@
// System.out.println(nr);
// Node node = createNonLeafNodeEqualProp();
// Concept node = pickFunctionSymbol();
- Concept child1 = createFullRandomTree(learningProblem, depth-1, useADC);
+ Description child1 = createFullRandomTree(learningProblem, depth-1, useADC);
if(nr == 0 || nr == 1) {
- Concept child2 = createFullRandomTree(learningProblem, depth-1, useADC);
+ Description child2 = createFullRandomTree(learningProblem, depth-1, useADC);
if(nr == 0) {
// if(useMultiStructures)
- return new MultiDisjunction(child1,child2);
+ return new Union(child1,child2);
// else
// return new Disjunction(child1,child2);
} else {
// if(useMultiStructures)
- return new MultiConjunction(child1, child2);
+ return new Intersection(child1, child2);
// else
// return new Conjunction(child1, child2);
}
} else if(nr==2) {
return new Negation(child1);
} else if(nr - 3 < numberOfRoles)
- return new Exists(learningProblem.getReasoningService().getAtomicRolesList().get(nr-3),child1);
+ return new ObjectSomeRestriction(learningProblem.getReasoningService().getAtomicRolesList().get(nr-3),child1);
else
- return new All(learningProblem.getReasoningService().getAtomicRolesList().get(nr-3-numberOfRoles),child1);
+ return new ObjectAllRestriction(learningProblem.getReasoningService().getAtomicRolesList().get(nr-3-numberOfRoles),child1);
/*
if(node instanceof Disjunction || node instanceof Conjunction) {
@@ -689,7 +689,7 @@
return createProgram(learningProblem, createGrowRandomTree(learningProblem, depth,false));
}
- private static Concept createGrowRandomTree(LearningProblem learningProblem, int depth, boolean useADC) {
+ private static Description createGrowRandomTree(LearningProblem learningProblem, int depth, boolean useADC) {
/*
private static Concept pickAlphabetSymbol(boolean useADC) {
FlatABox abox = FlatABox.getInstance();
@@ -761,30 +761,30 @@
// Concept node = pickAlphabetSymbol(useADC);
if(nr==0)
- return new Top();
+ return new Thing();
else if(nr==1)
- return new Bottom();
+ return new Nothing();
// ADC bekommt die h�chste Nummer, die nur in diesem Fall m�glich ist
else if(nr==numberOfConcepts + 2*numberOfRoles + 5)
return new ADC();
else if(nr>=2 && nr < numberOfConcepts+2)
- return (AtomicConcept)learningProblem.getReasoningService().getAtomicConceptsList().get(nr-2).clone();
+ return (NamedClass)learningProblem.getReasoningService().getAtomicConceptsList().get(nr-2).clone();
else if(nr==numberOfConcepts+2) {
// if(useMultiStructures)
- return new MultiConjunction(createGrowRandomTree(learningProblem, depth-1, useADC),createGrowRandomTree(learningProblem, depth-1, useADC));
+ return new Intersection(createGrowRandomTree(learningProblem, depth-1, useADC),createGrowRandomTree(learningProblem, depth-1, useADC));
// else
// return new Conjunction(createGrowRandomTree(learningProblem, depth-1, useADC),createGrowRandomTree(learningProblem, depth-1, useADC));
} else if(nr==numberOfConcepts+3) {
// if(useMultiStructures)
- return new MultiDisjunction(createGrowRandomTree(learningProblem, depth-1, useADC),createGrowRandomTree(learningProblem, depth-1, useADC));
+ return new Union(createGrowRandomTree(learningProblem, depth-1, useADC),createGrowRandomTree(learningProblem, depth-1, useADC));
// else
// return new Disjunction(createGrowRandomTree(learningProblem, depth-1, useADC),createGrowRandomTree(learningProblem, depth-1, useADC));
} else if(nr==numberOfConcepts+4)
return new Negation(createGrowRandomTree(learningProblem, depth-1, useADC));
else if(nr>=numberOfConcepts+5 && nr<numberOfConcepts+5+numberOfRoles)
- return new Exists(learningProblem.getReasoningService().getAtomicRolesList().get(nr-numberOfConcepts-5),createGrowRandomTree(learningProblem,depth-1, useADC));
+ return new ObjectSomeRestriction(learningProblem.getReasoningService().getAtomicRolesList().get(nr-numberOfConcepts-5),createGrowRandomTree(learningProblem,depth-1, useADC));
else
- return new All(learningProblem.getReasoningService().getAtomicRolesList().get(nr-numberOfConcepts-5-numberOfRoles),createGrowRandomTree(learningProblem,depth-1, useADC));
+ return new ObjectAllRestriction(learningProblem.getReasoningService().getAtomicRolesList().get(nr-numberOfConcepts-5-numberOfRoles),createGrowRandomTree(learningProblem,depth-1, useADC));
/*
if(node instanceof Disjunction || node instanceof Conjunction) {
@@ -812,14 +812,14 @@
return checkTree(prog.getTree(), true);
}
- public static boolean checkTree(Concept node, boolean isRootNode) {
+ public static boolean checkTree(Description node, boolean isRootNode) {
if(isRootNode && node.getParent()!=null) {
System.out.println("inconsistent root");
return false;
}
// Kinder �berpr�fen
- for(Concept child : node.getChildren()) {
+ for(Description child : node.getChildren()) {
if(!child.getParent().equals(node)) {
System.out.println("inconsistent tree " + node + " (child " + child + ")");
return false;
Modified: trunk/src/dl-learner/org/dllearner/algorithms/gp/Program.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/algorithms/gp/Program.java 2008-02-11 17:41:10 UTC (rev 541)
+++ trunk/src/dl-learner/org/dllearner/algorithms/gp/Program.java 2008-02-11 18:50:44 UTC (rev 542)
@@ -21,7 +21,7 @@
package org.dllearner.algorithms.gp;
import org.dllearner.core.Score;
-import org.dllearner.core.owl.Concept;
+import org.dllearner.core.owl.Description;
/**
* This class represents a program, i.e. an individual.
@@ -33,11 +33,11 @@
// public static int fitnessEvaluations = 0;
- private Concept hypothesis;
+ private Description hypothesis;
// private Concept extendedHypothesis;
- private Concept adc;
+ private Description adc;
private Score score;
@@ -53,11 +53,11 @@
* @param concept
* The program tree.
*/
- public Program(Score score, Concept hypothesis) {
+ public Program(Score score, Description hypothesis) {
this(score, hypothesis, null);
}
- public Program(Score score, Concept hypothesis, Concept adc) {
+ public Program(Score score, Description hypothesis, Description adc) {
// this.learningProblem = learningProblem;
this.score = score;
this.hypothesis = hypothesis;
@@ -126,7 +126,7 @@
*
* @return The program tree.
*/
- public Concept getTree() {
+ public Description getTree() {
return hypothesis;
}
@@ -134,7 +134,7 @@
return score;
}
- public Concept getAdc() {
+ public Description getAdc() {
return adc;
}
}
Modified: trunk/src/dl-learner/org/dllearner/algorithms/hybridgp/Psi.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/algorithms/hybridgp/Psi.java 2008-02-11 17:41:10 UTC (rev 541)
+++ trunk/src/dl-learner/org/dllearner/algorithms/hybridgp/Psi.java 2008-02-11 18:50:44 UTC (rev 542)
@@ -7,7 +7,7 @@
import org.dllearner.algorithms.gp.Program;
import org.dllearner.core.Score;
-import org.dllearner.core.owl.Concept;
+import org.dllearner.core.owl.Description;
import org.dllearner.learningproblems.PosNegLP;
import org.dllearner.utilities.ConceptComparator;
import org.dllearner.utilities.ConceptTransformation;
@@ -23,12 +23,12 @@
// Cache, damit keine Konzepte doppelt ausgewertet werden
ConceptComparator conceptComparator = new ConceptComparator();
- public SortedMap<Concept,Score> evalCache = new TreeMap<Concept,Score>(conceptComparator);
+ public SortedMap<Description,Score> evalCache = new TreeMap<Description,Score>(conceptComparator);
// Cache, damit PsiDown bzw. PsiUp nicht mehrfach für gleiches Konzept
// aufgerufen werden
- public SortedMap<Concept,Set<Concept>> pdCache = new TreeMap<Concept,Set<Concept>>(conceptComparator);
- public SortedMap<Concept,Set<Concept>> puCache = new TreeMap<Concept,Set<Concept>>(conceptComparator);
+ public SortedMap<Description,Set<Description>> pdCache = new TreeMap<Description,Set<Description>>(conceptComparator);
+ public SortedMap<Description,Set<Description>> puCache = new TreeMap<Description,Set<Description>>(conceptComparator);
// Statistiken
int conceptCacheHits = 0;
@@ -57,7 +57,7 @@
random = new Random();
}
- public Concept applyPsi(Concept concept, int coveredPositives, int coveredNegatives) {
+ public Description applyPsi(Description concept, int coveredPositives, int coveredNegatives) {
// Wahrscheinlichkeit für upward refinement berechnen
double tmp = coveredNegatives/(double)nrOfNegativeExamples;
double tmp2 = coveredPositives/(double)nrOfPositiveExamples;
@@ -92,7 +92,7 @@
// someTimeStart = System.nanoTime();
// downward oder upward refinement operator anwenden
- Set<Concept> refinements;
+ Set<Description> refinements;
if(downward) {
pdRequests++;
// Cache aufrufen
@@ -137,7 +137,7 @@
// ein refinement zufällig auswählen
- Concept[] array = refinements.toArray(new Concept[0]);
+ Description[] array = refinements.toArray(new Description[0]);
// kein refinement gefunden
if(array.length==0) {
if(debug) {
@@ -149,12 +149,12 @@
}
int position = random.nextInt(array.length);
- Concept returnConcept = array[position];
+ Description returnConcept = array[position];
ConceptTransformation.cleanConcept(returnConcept);
// das Rückgabekonzept wird geklont, damit alle parent-Links repariert
// werden (damit andere GP-Operatoren korrekt funktionieren)
- Concept returnConceptClone = (Concept)returnConcept.clone();
+ Description returnConceptClone = (Description)returnConcept.clone();
returnConceptClone.setParent(null);
if(debug) {
@@ -169,7 +169,7 @@
psiApplicationStartTime = System.nanoTime();
nrOfRequests++;
- Concept concept = program.getTree();
+ Description concept = program.getTree();
// es muss sichergestellt sein, dass Konjunktionen nur als MultConjunctions
// vorhanden sind (analog bei Disjunktion) => effizienter wäre eine Auslagerung
// dieses Codes in die Konzepterzeugung, da die Transformation häufig nichts
@@ -180,11 +180,11 @@
// sich lohnt Operatoren zu definieren, die keine Negationsnormalform
// erfordern)
- Concept conceptMod = ConceptTransformation.transformToNegationNormalForm(concept);
+ Description conceptMod = ConceptTransformation.transformToNegationNormalForm(concept);
// um mehr Cache Hits zu bekommen, wird noch vereinfach und geordnet
- Concept conceptModForCache = ConceptTransformation.applyEquivalenceRules(conceptMod);
+ Description conceptModForCache = ConceptTransformation.applyEquivalenceRules(conceptMod);
ConceptTransformation.transformToOrderedNegationNormalForm(conceptModForCache, conceptComparator);
Score score = program.getScore();
@@ -196,14 +196,14 @@
int coveredPositives = score.getCoveredPositives().size();
int coveredNegatives = score.getCoveredNegatives().size();
// someTimeStart = System.nanoTime();
- Concept newConcept = applyPsi(conceptMod, coveredPositives, coveredNegatives);
+ Description newConcept = applyPsi(conceptMod, coveredPositives, coveredNegatives);
ConceptTransformation.cleanConcept(newConcept);
// someTime += System.nanoTime() - someTimeStart;
// newConcept.setParent(null);
/////////// TESTCODE: umwandeln des erhaltenen Konzepts
// someTimeStart = System.nanoTime();
- Concept newConceptMod = ConceptTransformation.applyEquivalenceRules(newConcept);
+ Description newConceptMod = ConceptTransformation.applyEquivalenceRules(newConcept);
ConceptTransformation.transformToOrderedNegationNormalForm(newConceptMod, conceptComparator);
// someTime += System.nanoTime() - someTimeStart;
///////////
@@ -278,11 +278,11 @@
return puRequests;
}
- public SortedMap<Concept, Set<Concept>> getPdCache() {
+ public SortedMap<Description, Set<Description>> getPdCache() {
return pdCache;
}
- public SortedMap<Concept, Set<Concept>> getPuCache() {
+ public SortedMap<Description, Set<Description>> getPuCache() {
return puCache;
}
Modified: trunk/src/dl-learner/org/dllearner/algorithms/hybridgp/PsiDown.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/algorithms/hybridgp/PsiDown.java 2008-02-11 17:41:10 UTC (rev 541)
+++ trunk/src/dl-learner/org/dllearner/algorithms/hybridgp/PsiDown.java 2008-02-11 18:50:44 UTC (rev 542)
@@ -9,17 +9,17 @@
import org.dllearner.algorithms.refinement.RefinementOperator;
import org.dllearner.core.ReasoningService;
-import org.dllearner.core.owl.All;
-import org.dllearner.core.owl.AtomicConcept;
-import org.dllearner.core.owl.Bottom;
-import org.dllearner.core.owl.Concept;
-import org.dllearner.core.owl.Exists;
-import org.dllearner.core.owl.MultiConjunction;
-import org.dllearner.core.owl.MultiDisjunction;
+import org.dllearner.core.owl.ObjectAllRestriction;
+import org.dllearner.core.owl.NamedClass;
+import org.dllearner.core.owl.Nothing;
+import org.dllearner.core.owl.Description;
+import org.dllearner.core.owl.ObjectSomeRestriction;
+import org.dllearner.core.owl.Intersection;
+import org.dllearner.core.owl.Union;
import org.dllearner.core.owl.Negation;
import org.dllearner.core.owl.ObjectProperty;
-import org.dllearner.core.owl.Quantification;
-import org.dllearner.core.owl.Top;
+import org.dllearner.core.owl.ObjectQuantorRestriction;
+import org.dllearner.core.owl.Thing;
import org.dllearner.learningproblems.PosNegLP;
import org.dllearner.utilities.ConceptComparator;
@@ -42,7 +42,7 @@
PosNegLP learningProblem;
ReasoningService reasoningService;
- private TreeSet<Concept> topSet;
+ private TreeSet<Description> topSet;
public PsiDown(PosNegLP learningProblem) {
this.learningProblem = learningProblem;
@@ -53,140 +53,140 @@
}
private void createTopSet() {
- topSet = new TreeSet<Concept>(conceptComparator);
+ topSet = new TreeSet<Description>(conceptComparator);
// TOP OR TOP => Was soll mit Refinements passieren, die immer improper sind?
- MultiDisjunction md = new MultiDisjunction();
- md.addChild(new Top());
- md.addChild(new Top());
+ Union md = new Union();
+ md.addChild(new Thing());
+ md.addChild(new Thing());
topSet.add(md);
// allgemeinste Konzepte
- topSet.addAll(reasoningService.getMoreSpecialConcepts(new Top()));
+ topSet.addAll(reasoningService.getMoreSpecialConcepts(new Thing()));
// negierte speziellste Konzepte
- Set<Concept> tmp = learningProblem.getReasoningService().getMoreGeneralConcepts(new Bottom());
- for(Concept c : tmp)
+ Set<Description> tmp = learningProblem.getReasoningService().getMoreGeneralConcepts(new Nothing());
+ for(Description c : tmp)
topSet.add(new Negation(c));
// EXISTS r.TOP und ALL r.TOP für alle r
for(ObjectProperty r : reasoningService.getAtomicRoles()) {
- topSet.add(new All(r, new Top()));
- topSet.add(new Exists(r, new Top()));
+ topSet.add(new ObjectAllRestriction(r, new Thing()));
+ topSet.add(new ObjectSomeRestriction(r, new Thing()));
}
}
@SuppressWarnings("unchecked")
- public Set<Concept> refine(Concept concept) {
+ public Set<Description> refine(Description concept) {
- Set<Concept> refinements = new HashSet<Concept>();
- Set<Concept> tmp = new HashSet<Concept>();
+ Set<Description> refinements = new HashSet<Description>();
+ Set<Description> tmp = new HashSet<Description>();
- if (concept instanceof Top) {
- return (Set<Concept>) topSet.clone();
- } else if (concept instanceof Bottom) {
+ if (concept instanceof Thing) {
+ return (Set<Description>) topSet.clone();
+ } else if (concept instanceof Nothing) {
// return new TreeSet<Concept>(conceptComparator);
- return new HashSet<Concept>();
- } else if (concept instanceof AtomicConcept) {
+ return new HashSet<Description>();
+ } else if (concept instanceof NamedClass) {
// beachte: die Funktion gibt bereits nur nicht-äquivalente Konzepte zurück
// beachte weiter: die zurückgegebenen Instanzen dürfen nicht verändert werden,
// da beim Caching der Subsumptionhierarchie (momentan) keine Kopien gemacht werden
// Bottom wird hier ggf. automatisch mit zurückgegeben
refinements.addAll(reasoningService.getMoreSpecialConcepts(concept));
// negiertes atomares Konzept
- } else if (concept instanceof Negation && concept.getChild(0) instanceof AtomicConcept) {
+ } else if (concept instanceof Negation && concept.getChild(0) instanceof NamedClass) {
tmp.addAll(reasoningService.getMoreGeneralConcepts(concept.getChild(0)));
// Top rausschmeissen
boolean containsTop = false;
- Iterator<Concept> it = tmp.iterator();
+ Iterator<Description> it = tmp.iterator();
while(it.hasNext()) {
- Concept c = it.next();
- if(c instanceof Top) {
+ Description c = it.next();
+ if(c instanceof Thing) {
it.remove();
containsTop = true;
}
}
if(containsTop)
- refinements.add(new Bottom());
+ refinements.add(new Nothing());
- for(Concept c : tmp) {
+ for(Description c : tmp) {
refinements.add(new Negation(c));
}
- } else if (concept instanceof MultiConjunction) {
+ } else if (concept instanceof Intersection) {
// eines der Elemente kann verfeinert werden
- for(Concept child : concept.getChildren()) {
+ for(Description child : concept.getChildren()) {
// Refinement für das Kind ausführen
tmp = refine(child);
// neue MultiConjunction konstruieren
- for(Concept c : tmp) {
+ for(Description c : tmp) {
// TODO: müssen auch alle Konzepte geklont werden??
// hier wird nur eine neue Liste erstellt
// => eigentlich muss nicht geklont werden (d.h. deep copy) da
// die Konzepte nicht verändert werden während des Algorithmus
- List<Concept> newChildren = new LinkedList<Concept>(concept.getChildren());
+ List<Description> newChildren = new LinkedList<Description>(concept.getChildren());
// es muss genau die vorherige Reihenfolge erhalten bleiben
// (zumindest bis die Normalform definiert ist)
int index = newChildren.indexOf(child);
newChildren.add(index, c);
newChildren.remove(child);
- MultiConjunction mc = new MultiConjunction(newChildren);
+ Intersection mc = new Intersection(newChildren);
refinements.add(mc);
}
}
- } else if (concept instanceof MultiDisjunction) {
+ } else if (concept instanceof Union) {
// eines der Elemente kann verfeinert werden
- for(Concept child : concept.getChildren()) {
+ for(Description child : concept.getChildren()) {
// Refinement für das Kind ausführen
// tmp = refine(child);
tmp = refine(child);
// neue MultiConjunction konstruieren
- for(Concept c : tmp) {
- List<Concept> newChildren = new LinkedList<Concept>(concept.getChildren());
+ for(Description c : tmp) {
+ List<Description> newChildren = new LinkedList<Description>(concept.getChildren());
// es muss genau die vorherige Reihenfolge erhalten bleiben
// (zumindest bis die Normalform definiert ist)
int index = newChildren.indexOf(child);
newChildren.add(index, c);
newChildren.remove(child);
- MultiDisjunction md = new MultiDisjunction(newChildren);
+ Union md = new Union(newChildren);
refinements.add(md);
}
}
// ein Element der Disjunktion kann weggelassen werden
- for(Concept child : concept.getChildren()) {
- List<Concept> newChildren = new LinkedList<Concept>(concept.getChildren());
+ for(Description child : concept.getChildren()) {
+ List<Description> newChildren = new LinkedList<Description>(concept.getChildren());
newChildren.remove(child);
// wenn nur ein Kind da ist, dann wird Disjunktion gleich weggelassen
if(newChildren.size()==1)
refinements.add(newChildren.get(0));
else {
- MultiDisjunction md = new MultiDisjunction(newChildren);
+ Union md = new Union(newChildren);
refinements.add(md);
}
}
- } else if (concept instanceof Exists) {
+ } else if (concept instanceof ObjectSomeRestriction) {
tmp = refine(concept.getChild(0));
- for(Concept c : tmp) {
- refinements.add(new Exists(((Quantification)concept).getRole(),c));
+ for(Description c : tmp) {
+ refinements.add(new ObjectSomeRestriction(((ObjectQuantorRestriction)concept).getRole(),c));
}
// falls Kind Bottom ist, dann kann exists weggelassen werden
- if(concept.getChild(0) instanceof Bottom)
- refinements.add(new Bottom());
+ if(concept.getChild(0) instanceof Nothing)
+ refinements.add(new Nothing());
- } else if (concept instanceof All) {
+ } else if (concept instanceof ObjectAllRestriction) {
tmp = refine(concept.getChild(0));
- for(Concept c : tmp) {
- refinements.add(new All(((Quantification)concept).getRole(),c));
+ for(Description c : tmp) {
+ refinements.add(new ObjectAllRestriction(((ObjectQuantorRestriction)concept).getRole(),c));
}
- if(concept.getChild(0) instanceof Bottom)
- refinements.add(new Bottom());
+ if(concept.getChild(0) instanceof Nothing)
+ refinements.add(new Nothing());
// falls es keine spezielleren atomaren Konzepte gibt, dann wird
// bottom angehangen => nur wenn es ein atomares Konzept (insbesondere != bottom)
@@ -200,13 +200,13 @@
// falls Konzept ungleich Bottom oder Top, dann kann ein Refinement von Top
// angehangen werden
- if(concept instanceof MultiDisjunction || concept instanceof AtomicConcept ||
- concept instanceof Negation || concept instanceof Exists || concept instanceof All) {
+ if(concept instanceof Union || concept instanceof NamedClass ||
+ concept instanceof Negation || concept instanceof ObjectSomeRestriction || concept instanceof ObjectAllRestriction) {
// es wird AND TOP angehangen
- MultiConjunction mc = new MultiConjunction();
+ Intersection mc = new Intersection();
mc.addChild(concept);
- mc.addChild(new Top());
+ mc.addChild(new Thing());
refinements.add(mc);
}
@@ -237,8 +237,8 @@
}
- public Set<Concept> refine(Concept concept, int maxLength,
- List<Concept> knownRefinements) {
+ public Set<Description> refine(Description concept, int maxLength,
+ List<Description> knownRefinements) {
throw new RuntimeException();
}
Modified: trunk/src/dl-learner/org/dllearner/algorithms/hybridgp/PsiUp.java
===================================================================
--- trunk/src/dl-learner/org/dllearner/algorithms/hybridgp/PsiUp.java 2008-02-11 17:41:10 UTC (rev 541)
+++ trunk/src/dl-learner/org/dllearner/algorithms/hybridgp/PsiUp.java 2008-02-11 18:50:44 UTC (rev 542)
@@ -9,17 +9,17 @@
import org.dllearner.algorithms.refinement.RefinementOperator;
import org.dllearner.core.ReasoningService;
-import org.dllearner.core.owl.All;
-import org.dllearner.core.owl.AtomicConcept;
-import org.dllearner.core.owl.Bottom;
-import org.dllearner.core.owl.Concept;
-import org.dllearner.core.owl.Exists;
-import org.dllearner.core.owl.MultiConjunction;
-import org.dllearner.core.owl.MultiDisjunction;
+import org.dllearner.core.owl.ObjectAllRestriction;
+import org.dllearner.core.owl.NamedClass;
+import org.dllearner.core.owl.Nothing;
+import org.dllearner.core.owl.Description;
+import org.dllearner.core.owl.ObjectSomeRestriction;
+import org.dllearner.core.owl.Intersection;
+import org.dllearner.core.owl.Union;
import org.dllearner.core.owl.Negation;
import org.dllearner.core.owl.ObjectProperty;
-import org.dllearner.core.owl.Quantification;
-import org.dllearner.core.owl.Top;
+import org.dllearner.core.owl.ObjectQuantorRestriction;
+import org.dllearner.core.owl.Thing;
import org.dllearner.learningproblems.PosNegLP;
import org.dllearner.utilities.ConceptComparator;
@@ -30,7 +30,7 @@
PosNegLP learningProblem;
ReasoningService reasoningService;
- private TreeSet<Concept> bottomSet;
+ private TreeSet<Description> bottomSet;
public PsiUp(PosNegLP learningProblem) {
this.learningProblem = learningProblem;
@@ -41,53 +41,53 @@
}
private void createBottomSet() {
- bottomSet = new TreeSet<Concept>(conceptComparator);
+ bottomSet = new TreeSet<Description>(conceptComparator);
// BOTTOM AND BOTTOM
- MultiConjunction mc = new MultiConjunction();
- mc.addChild(new Bottom());
- mc.addChild(new Bottom());
+ Intersection mc = new Intersection();
+ mc.addChild(new Nothing());
+ mc.addChild(new Nothing());
bottomSet.add(mc);
// speziellste Konzepte
- bottomSet.addAll(reasoningService.getMoreGeneralConcepts(new Bottom()));
+ bottomSet.addAll(reasoningService.getMoreGeneralConcepts(new Nothing()));
// negierte allgemeinste Konzepte
- Set<Concept> tmp = reasoningService.getMoreSpecialConcepts(new Top());
- for(Concept c : tmp)
+ Set<Description> tmp = reasoningService.getMoreSpecialConcepts(new Thing());
+ for(Description c : tmp)
bottomSet.add(new Negation(c));
// EXISTS r.BOTTOM und ALL r.BOTTOM für alle r
for(ObjectProperty r : reasoningService.getAtomicRoles()) {
- bottomSet.add(new All(r, new Bottom()));
- bottomSet.add(new Exists(r, new Bottom()));
+ bottomSet.add(new ObjectAllRestriction(r, new Nothing()));
+ bottomSet.add(new ObjectSomeRestriction(r, new Nothing()));
}
}
@SuppressWarnings("unchecked")
- public Set<Concept> refine(Concept concept) {
+ public Set<Description> refine(Description concept) {
- Set<Concept> refinements = new HashSet<Concept>();
- Set<Concept> tmp = new HashSet<Concept>();
+ Set<Description> refinements = new HashSet<Description>();
+ Set<Description> tmp = new HashSet<Description>();
- if (concept instanceof Top) {
- return new TreeSet<Concept>(conceptComparator);
- } else if (concept instanceof Bottom) {
- return (Set<Concept>) bottomSet.clone();
- } else if (concept instanceof AtomicConcept) {
+ if (concept instanceof Thing) {
+ return new TreeSet<Description>(conceptComparator);
+ } else if (concept instanceof Nothing) {
+ return (Set<Description>) bottomSet.clone();
+ } else if (concept instanceof NamedClass) {
// Top darf hier mit dabei sein
refinements.addAll(reasoningService.getMoreGeneralConcepts(concept));
// negiertes atomares Konzept
- } else if (concept instanceof Negation && concept.getChild(0) instanceof AtomicConcept) {
+ } else if (concept instanceof Negation && concept.getChild(0) instanceof NamedClass) {
tmp.addAll(reasoningService.getMoreSpecialConcepts(concept.getChild(0)));
// Bottom rausschmeissen
boolean containsBottom = false;
- Iterator<Concept> it = tmp.iterator();
+ Iterator<Description> it = tmp.iterator();
while(it.hasNext()) {
- Concept c = it.next();
- if(c instanceof Bottom) {
+ Description c = it.next();
+ if(c instanceof Nothing) {
it.remove();
containsBottom = true;
}
@@ -95,82 +95,82 @@
// es soll z.B. NOT male auch zu NOT BOTTOM d.h. zu TOP verfeinert
// werden können
if(containsBottom)
- refinements.add(new Top());
+ refinements.add(new Thing());
- for(Concept c : tmp) {
+ for(Description c : tmp) {
refinements.add(new Negation(c));
}
- } else if (concept instanceof MultiConjunction) {
+ } else if (concept instanceof Intersection) {
// eines der Elemente kann verfeinert werden
- for(Concept child : concept.getChildren()) {
+ for(Description child : concept.getChildren()) {
// Refinement für das Kind ausführen
tmp = refine(child);
// neue MultiConjunction konstruieren
- for(Concept c : tmp) {
+ for(Description c : tmp) {
// TODO: müssen auch alle Konzepte geklont werden??
// hier wird nur eine neue Liste erstellt
// => eigentlich muss nicht geklont werden (d.h. deep copy) da
// die Konzepte nicht verändert werden während des Algorithmus
- List<Concept> newChildren = new LinkedList<Concept>(concept.getChildren());
+ List<Description> newChildren = new LinkedList<Description>(concept.getChildren());
// es muss genau die vorherige Reihenfolge erhalten bleiben
// (zumindest bis die Normalform definiert ist)
int index = newChildren.indexOf(child);
newChildren.add(index, c);
newChildren.remove(child);
- MultiConjunction mc = new MultiConjunction(...
[truncated message content] |
