- fixed a defect in the FOLOTTERLikeTheorem prover, whereby its lightest clause heuristic was not cleaning down its SOS between calls to ask().

- put a hard coded learned Hypothesis into the CurrentBestLearning algorithm implementation in order to ensure supporting infrastructure in place.
- Made the underlying translation from a DataSetSpecification to FOL more robust to non java identifiers (i.e. affects the FOLLexer).

Author: ctjoreilly

src/aima/learning/knowledge/CurrentBestLearning.java

@@ -2,6 +2,9 @@
 
 import java.util.List;
 
+import aima.logic.fol.kb.FOLKnowledgeBase;
+import aima.logic.fol.kb.data.Clause;
+
 /**
  * Artificial Intelligence A Modern Approach (2nd Edition): Figure 19.2, page 681.
  * 
@@ -28,20 +31,27 @@
  */
 public class CurrentBestLearning {
 	private FOLDataSetDomain folDSDomain = null;
+	private FOLKnowledgeBase kbForLearning = null;
 
 	//
 	// PUBLIC METHODS
 	//
-	public CurrentBestLearning(FOLDataSetDomain folDSDomain) {
+	public CurrentBestLearning(FOLDataSetDomain folDSDomain, FOLKnowledgeBase kbForLearning) {
 		this.folDSDomain = folDSDomain;
+		this.kbForLearning = kbForLearning;
 	}
 
 	// * function CURRENT-BEST-LEARNING(examples) returns a hypothesis
 	public Hypothesis currentBestLearning(List<FOLExample> examples) {
-		// TODO-remove this test behavior code
-//		for (FOLExample fe : examples) {
-//			System.out.println(fe.toString());
-//		}
+		
+		// TODO-use the default from pg 679 for now.
+		String c1 = "patrons(v,Some)";
+		String c2 = "patrons(v,Full) AND (hungry(v) AND type(v,French))";
+		String c3 = "patrons(v,Full) AND (hungry(v) AND (type(v,Thai) AND fri_sat(v)))";
+		String c4 = "patrons(v,Full) AND (hungry(v) AND type(v,Burger))";
+		String sh = "FORALL v (will_wait(v) <=> ("+c1+" OR ("+c2+" OR ("+c3+" OR ("+c4+")))))";
+		
+		Hypothesis H = new Hypothesis(kbForLearning.tell(sh));
 
 		// TODO
 		// * H <- any hypothesis consistent with the first example in examples.
@@ -53,7 +63,7 @@ public Hypothesis currentBestLearning(List<FOLExample> examples) {
 		// * if no consistent specialization/generalization can be found then
 		// fail
 		// * return H
-		return null;
+		return H;
 	}
 
 	//

src/aima/learning/knowledge/FOLDataSetDomain.java

@@ -1,7 +1,10 @@
 package aima.learning.knowledge;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
 
 import aima.learning.framework.DataSetSpecification;
 import aima.logic.fol.domain.FOLDomain;
@@ -11,11 +14,16 @@
  * 
  */
 public class FOLDataSetDomain extends FOLDomain {
+	//
+	private static Pattern allowableCharactersRegEx = Pattern.compile("[^a-zA-Z_$0-9]");
+	//
 	private DataSetSpecification dataSetSpecification;
 	private String trueGoalValue = null;
 	// Default example prefix, see pg679 of AIMA
 	private String examplePrefix = "X"; 
 	private List<String> descriptionPredicateNames = new ArrayList<String>();
+	private List<String> descriptionDataSetNames = new ArrayList<String>();
+	private Map<String, String> dsToFOLNameMap = new HashMap<String, String>();
 
 	//
 	// PUBLIC METHODS
@@ -26,10 +34,14 @@ public FOLDataSetDomain(DataSetSpecification dataSetSpecification, String trueGo
 		constructFOLDomain();
 	}
 
-	public String getGoalPredicateName() {
+	public String getDataSetTargetName() {
 		return dataSetSpecification.getTarget();
 	}
 
+	public String getGoalPredicateName() {
+		return getFOLName(dataSetSpecification.getTarget());
+	}
+	
 	public String getTrueGoalValue() {
 		return trueGoalValue;
 	}
@@ -38,8 +50,12 @@ public List<String> getDescriptionPredicateNames() {
 		return descriptionPredicateNames;
 	}
 
-	public boolean isMultivalued(String descriptivePredicateName) {
-		List<String> possibleValues = dataSetSpecification.getPossibleAttributeValues(descriptivePredicateName);
+	public List<String> getDescriptionDataSetNames() {
+		return descriptionDataSetNames;
+	}
+	
+	public boolean isMultivalued(String descriptiveDataSetName) {
+		List<String> possibleValues = dataSetSpecification.getPossibleAttributeValues(descriptiveDataSetName);
 		// If more than two possible values
 		// then is multivalued
 		if (possibleValues.size() > 2) {
@@ -63,29 +79,45 @@ public String getExampleConstant(int egNo) {
 		return egConstant;
 	}
 
+	public String getFOLName(String dsName) {
+		String folName = dsToFOLNameMap.get(dsName);
+		if (null == folName) {
+			folName = dsName;
+			if (!Character.isJavaIdentifierStart(dsName.charAt(0))) {
+				folName = "_"+dsName;
+			}
+			folName = allowableCharactersRegEx.matcher(folName).replaceAll("_");
+			dsToFOLNameMap.put(dsName, folName);
+		}
+		
+		return folName;
+	}
+	
 	//
 	// PRIVATE METHODS
 	//
 	private void constructFOLDomain() {
 		// Ensure the target predicate is included
-		addPredicate(dataSetSpecification.getTarget());
+		addPredicate(getFOLName(dataSetSpecification.getTarget()));
 		// Create the descriptive predicates
 		for (String saName : dataSetSpecification.getNamesOfStringAttributes()) {			
 			if (dataSetSpecification.getTarget().equals(saName)) {
 				// Don't add the target to the descriptive predicates
 				continue;
 			}
+			String folSAName = getFOLName(saName);
 			// Add a predicate for the attribute
-			addPredicate(saName);
+			addPredicate(folSAName);
 
-			descriptionPredicateNames.add(saName);
+			descriptionPredicateNames.add(folSAName);
+			descriptionDataSetNames.add(saName);
 
 			List<String> attributeValues = dataSetSpecification.getPossibleAttributeValues(saName);
 			// If a multivalued attribute need to setup
 			// Constants for the different possible values
 			if (isMultivalued(saName)) {
 				for (String av : attributeValues) {
-					addConstant(av);
+					addConstant(getFOLName(av));
 				}
 			}
 		}

src/aima/learning/knowledge/FOLExample.java

@@ -62,15 +62,16 @@ private void constructFOLEg() {
 		// Create the classification sentence
 		classification = new Predicate(folDSDomain.getGoalPredicateName(), terms);
 		if (!example.getAttributeValueAsString(
-				folDSDomain.getGoalPredicateName()).equals(
+				folDSDomain.getDataSetTargetName()).equals(
 				folDSDomain.getTrueGoalValue())) {
 			// if not true then needs to be a Not sentence
 			classification = new NotSentence(classification);
 		} 
 
 		// Create the description sentence
 		List<Sentence> descParts = new ArrayList<Sentence>();
-		for (String dname : folDSDomain.getDescriptionPredicateNames()) {
+		for (String dname : folDSDomain.getDescriptionDataSetNames()) {
+			String foldDName = folDSDomain.getFOLName(dname);
 			terms = new ArrayList<Term>();
 			terms.add(ithExampleConstant);
 			// If multivalued becomes a two place predicate
@@ -79,10 +80,10 @@ private void constructFOLEg() {
 			// see pg 679 of AIMA
 			Sentence part = null;
 			if (folDSDomain.isMultivalued(dname)) {
-				terms.add(new Constant(example.getAttributeValueAsString(dname)));
-				part = new Predicate(dname, terms);
+				terms.add(new Constant(folDSDomain.getFOLName(example.getAttributeValueAsString(dname))));
+				part = new Predicate(foldDName, terms);
 			} else {
-				part = new Predicate(dname, terms);
+				part = new Predicate(foldDName, terms);
 				// Need to determine if false
 				if (!folDSDomain.getTrueGoalValue().equals(example.getAttributeValueAsString(dname))) {
 					part = new NotSentence(part);

src/aima/learning/knowledge/Hypothesis.java

@@ -1,9 +1,28 @@
 package aima.learning.knowledge;
 
+import aima.logic.fol.parsing.ast.Sentence;
+
 /**
  * @author Ciaran O'Reilly
  * 
  */
 public class Hypothesis {
-
+	private Sentence hypothesis = null;
+	
+	public Hypothesis(Sentence hypothesis) {
+		this.hypothesis = hypothesis;
+	}
+	
+	/**
+	 * <pre>
+	 * FORALL v (Classification(v) <=> ((Description1(v) AND Description2(v, Constant1))
+     *	                                OR
+	 *                                  (Description1(v) AND Description3(v))
+	 *                                 )
+	 *          )
+	 * </pre>
+	 */
+	public Sentence getHypothesis() {
+		return hypothesis;
+	}
 }

src/aima/learning/learners/CurrentBestLearner.java

@@ -10,13 +10,19 @@
 import aima.learning.knowledge.FOLDataSetDomain;
 import aima.learning.knowledge.FOLExample;
 import aima.learning.knowledge.Hypothesis;
+import aima.logic.fol.inference.FOLModelElimination;
+import aima.logic.fol.inference.InferenceResult;
+import aima.logic.fol.kb.FOLKnowledgeBase;
 
 /**
  * @author Ciaran O'Reilly
  * 
  */
 public class CurrentBestLearner implements Learner {
 	private String trueGoalValue = null;
+	private FOLDataSetDomain folDSDomain = null;
+	private FOLKnowledgeBase kb = null;
+	private Hypothesis currentBestHypothesis = null;
 
 	//
 	// PUBLIC METHODS
@@ -28,25 +34,43 @@ public CurrentBestLearner(String trueGoalValue) {
 	//
 	// START-Learner
 	public void train(DataSet ds) {
-		FOLDataSetDomain folDSDomain = new FOLDataSetDomain(ds.specification,
-				trueGoalValue);
+		folDSDomain = new FOLDataSetDomain(ds.specification, trueGoalValue);
 		List<FOLExample> folExamples = new ArrayList<FOLExample>();
 		int egNo = 1;
 		for (Example e : ds.examples) {
 			folExamples.add(new FOLExample(folDSDomain, e, egNo));
 			egNo++;
 		}
 
-		CurrentBestLearning cbl = new CurrentBestLearning(folDSDomain);
+		// Setup a KB to be used for learning
+		kb = new FOLKnowledgeBase(folDSDomain, new FOLModelElimination(1000));
 
-		Hypothesis h = cbl.currentBestLearning(folExamples);
+		CurrentBestLearning cbl = new CurrentBestLearning(folDSDomain, kb);
 
-		// TODO
+		currentBestHypothesis = cbl.currentBestLearning(folExamples);
 	}
 
 	public String predict(Example e) {
-		// TODO
-		return null;
+		String prediction = "~" + e.targetValue();
+		if (null != currentBestHypothesis) {
+			FOLExample etp = new FOLExample(folDSDomain, e, 0);
+			kb.clear();
+			kb.tell(etp.getDescription());
+			kb.tell(currentBestHypothesis.getHypothesis());
+
+			InferenceResult ir = kb.ask(etp.getClassification());
+			if (ir.isTrue()) {
+				prediction = e.targetValue();
+			} else if (ir.isUnknownDueToTimeout()) {
+				// If unknown due to timeout then assume
+				// is true by default, as can't prove
+				// either way based on known hypothesis,
+				// facts and available time.
+				prediction = e.targetValue();
+			}
+		}
+
+		return prediction;
 	}
 
 	public int[] test(DataSet ds) {

src/aima/logic/fol/inference/InferenceResultPrinter.java

@@ -0,0 +1,37 @@
+package aima.logic.fol.inference;
+
+import aima.logic.fol.inference.proof.Proof;
+import aima.logic.fol.inference.proof.ProofPrinter;
+
+/**
+ * @author Ciaran O'Reilly
+ * 
+ */
+public class InferenceResultPrinter {
+	/**
+	 * Utility method for outputting InferenceResults in a formatted textual
+	 * representation.
+	 * 
+	 * @param an
+	 *            InferenceResult
+	 * @return a String representation of the InferenceResult.
+	 */
+	public static String printInferenceResult(InferenceResult ir) {
+		StringBuilder sb = new StringBuilder();
+
+		sb.append("InferenceResult.isTrue=" + ir.isTrue());
+		sb.append("InferenceResult.isPossiblyFalse=" + ir.isPossiblyFalse());
+		sb.append("InferenceResult.isUnknownDueToTimeout="
+				+ ir.isUnknownDueToTimeout());
+		sb.append("InferenceResult.isPartialResultDueToTimeout="
+				+ ir.isPartialResultDueToTimeout());
+		sb.append("InferenceResult.#Proofs=" + ir.getProofs().size());
+		int proofNo = 0;
+		for (Proof p : ir.getProofs()) {
+			proofNo++;
+			sb.append("InferenceResult.Proof#"+proofNo+"=\n" + ProofPrinter.printProof(p));
+		}
+
+		return sb.toString();
+	}
+}

src/aima/logic/fol/inference/otter/defaultimpl/DefaultLightestClauseHeuristic.java

@@ -35,6 +35,7 @@ public Clause getLightestClause() {
 	}
 
 	public void initialSOS(Set<Clause> clauses) {
+		sos.clear();
 		sos.addAll(clauses);
 		Collections.sort(sos, lightestClauseSorter);
 	}

src/aima/logic/fol/kb/FOLKnowledgeBase.java

@@ -96,6 +96,14 @@ public FOLKnowledgeBase(FOLDomain domain,
 				substVisitor);
 		this.cnfConverter = new CNFConverter(parser);
 	}
+	
+	public void clear() {
+		this.originalSentences.clear();
+		this.clauses.clear();
+		this.allDefiniteClauses.clear();
+		this.implicationDefiniteClauses.clear();
+		this.indexFacts.clear();
+	}
 
 	public InferenceProcedure getInferenceProcedure() {
 		return inferenceProcedure;
@@ -107,8 +115,10 @@ public void setInferenceProcedure(InferenceProcedure inferenceProcedure) {
 		}
 	}
 
-	public void tell(String aSentence) {
-		tell(parser.parse(aSentence));
+	public Sentence tell(String aSentence) {
+		Sentence s = parser.parse(aSentence);
+		tell(s);
+		return s;
 	}
 
 	public void tell(List<? extends Sentence> sentences) {

src/aima/test/learningtest/LearnerTests.java

@@ -131,9 +131,9 @@ public void testCurrentBestLearnerOnRestaurantDataSet() throws Exception {
 		DataSet ds = DataSetFactory.getRestaurantDataSet();
 		CurrentBestLearner learner = new CurrentBestLearner("Yes");
 		learner.train(ds);
-		// TODO
-		//int[] result = learner.test(ds);
-		//assertEquals(12, result[0]);
-		//assertEquals(0, result[1]);
+
+		int[] result = learner.test(ds);
+		assertEquals(12, result[0]);
+		assertEquals(0, result[1]);
 	}
 }