added csp, logic, planning and probability .ipynb (#1130)

* changed queue to set in AC3

Changed queue to set in AC3 (as in the pseudocode of the original algorithm) to reduce the number of consistency-check due to the redundancy of the same arcs in queue. For example, on the harder1 configuration of the Sudoku CSP the number consistency-check has been reduced from 40464 to 12562!

* re-added test commented by mistake

* added the mentioned AC4 algorithm for constraint propagation

AC3 algorithm has non-optimal worst case time-complexity O(cd^3 ), while AC4 algorithm runs in O(cd^2) worst case time

* added doctest in Sudoku for AC4 and and the possibility of choosing the constant propagation algorithm in mac inference

* removed useless doctest for AC4 in Sudoku because AC4's tests are already present in test_csp.py

* added map coloring SAT problems

* fixed typo errors and removed unnecessary brackets

* reformulated the map coloring problem

* Revert "reformulated the map coloring problem"

This reverts commit 20ab0e5.

* Revert "fixed typo errors and removed unnecessary brackets"

This reverts commit f743146.

* Revert "added map coloring SAT problems"

This reverts commit 9e0fa55.

* Revert "removed useless doctest for AC4 in Sudoku because AC4's tests are already present in test_csp.py"

This reverts commit b3cd24c.

* Revert "added doctest in Sudoku for AC4 and and the possibility of choosing the constant propagation algorithm in mac inference"

This reverts commit 6986247.

* Revert "added the mentioned AC4 algorithm for constraint propagation"

This reverts commit 03551fb.

* added map coloring SAT problem

* fixed build error

* Revert "added map coloring SAT problem"

This reverts commit 93af259.

* Revert "fixed build error"

This reverts commit 6641c2c.

* added map coloring SAT problem

* removed redundant parentheses

* added Viterbi algorithm

* added monkey & bananas planning problem

* simplified condition in search.py

* added tests for monkey & bananas planning problem

* removed monkey & bananas planning problem

* Revert "removed monkey & bananas planning problem"

This reverts commit 9d37ae0.

* Revert "added tests for monkey & bananas planning problem"

This reverts commit 24041e9.

* Revert "simplified condition in search.py"

This reverts commit 6d229ce.

* Revert "added monkey & bananas planning problem"

This reverts commit c74933a.

* defined the PlanningProblem as a specialization of a search.Problem & fixed typo errors

* fixed doctest in logic.py

* fixed doctest for cascade_distribution

* added ForwardPlanner and tests

* added __lt__ implementation for Expr

* added more tests

* renamed forward planner

* Revert "renamed forward planner"

This reverts commit c4139e5.

* renamed forward planner class & added doc

* added backward planner and tests

* fixed mdp4e.py doctests

* removed ignore_delete_lists_heuristic flag

* fixed heuristic for forward and backward planners

* added SATPlan and tests

* fixed ignore delete lists heuristic in forward and backward planners

* fixed backward planner and added tests

* updated doc

* added nary csp definition and examples

* added CSPlan and tests

* fixed CSPlan

* added book's cryptarithmetic puzzle example

* fixed typo errors in test_csp

* fixed #1111

* added sortedcontainers to yml and doc to CSPlan

* added tests for n-ary csp

* fixed utils.extend

* updated test_probability.py

* converted static methods to functions

* added AC3b and AC4 with heuristic and tests

* added conflict-driven clause learning sat solver

* added tests for cdcl and heuristics

* fixed probability.py

* fixed import

* fixed kakuro

* added Martelli and Montanari rule-based unification algorithm

* removed duplicate standardize_variables

* renamed variables known as built-in functions

* fixed typos in learning.py

* renamed some files and fixed typos

* fixed typos

* fixed typos

* fixed tests

* removed unify_mm

* remove unnecessary brackets

* fixed tests

* moved utility functions to utils.py

* fixed typos

* moved utils function to utils.py, separated probability learning classes from learning.py, fixed typos and fixed imports in .ipynb files

* added missing learners

* fixed Travis build

* fixed typos

* fixed typos

* fixed typos

* fixed typos

* fixed typos in agents files

* fixed imports in agent files

* fixed deep learning .ipynb imports

* fixed typos

* added .ipynb and fixed typos

* adapted code for .ipynb

* fixed typos

* updated .ipynb

* updated .ipynb

* updated logic.py

* updated .ipynb

* updated .ipynb

* updated planning.py

* updated inf definition

* fixed typos

* fixed typos

* fixed typos

* fixed typos

* Revert "fixed typos"

This reverts commit 658309d.

* Revert "fixed typos"

This reverts commit 08ad660.

* fixed typos

* fixed typos

* fixed typos

* fixed typos

* fixed typos and utils imports in *4e.py files

Author: dmeoli

arc_consistency_heuristics.ipynb

@@ -10,7 +10,7 @@
 from keras.models import Sequential
 from keras.preprocessing import sequence
 
-from utils4e import (sigmoid, dotproduct, softmax1D, conv1D, GaussianKernel, element_wise_product, vector_add,
+from utils4e import (sigmoid, dot_product, softmax1D, conv1D, GaussianKernel, element_wise_product, vector_add,
                      random_weights, scalar_vector_product, matrix_multiplication, map_vector, mse_loss)
 
 
@@ -107,7 +107,7 @@ def forward(self, inputs):
         res = []
         # get the output value of each unit
         for unit in self.nodes:
-            val = self.activation.f(dotproduct(unit.weights, inputs))
+            val = self.activation.f(dot_product(unit.weights, inputs))
             unit.val = val
             res.append(val)
         return res

classical_planning_approaches.ipynb

@@ -4,9 +4,8 @@
 import random
 import itertools
 import copy
-from utils import argmax, vector_add
+from utils import argmax, vector_add, inf
 
-inf = float('inf')
 GameState = namedtuple('GameState', 'to_move, utility, board, moves')
 StochasticGameState = namedtuple('StochasticGameState', 'to_move, utility, board, moves, chance')
 

csp.py

@@ -4,9 +4,8 @@
 import random
 import itertools
 import copy
-from utils import argmax, vector_add, MCT_Node, ucb
+from utils4e import argmax, vector_add, MCT_Node, ucb, inf
 
-inf = float('inf')
 GameState = namedtuple('GameState', 'to_move, utility, board, moves')
 StochasticGameState = namedtuple('StochasticGameState', 'to_move, utility, board, moves, chance')
 
@@ -187,8 +186,8 @@ def select(n):
     def expand(n):
         """expand the leaf node by adding all its children states"""
         if not n.children and not game.terminal_test(n.state):
-            n.children = {MCT_Node(state=game.result(n.state, action), parent=n): action for action in
-                          game.actions(n.state)}
+            n.children = {MCT_Node(state=game.result(n.state, action), parent=n): action
+                          for action in game.actions(n.state)}
         return select(n)
 
     def simulate(game, state):

deep_learning4e.py

@@ -14,7 +14,8 @@
 
 
 def current_best_learning(examples, h, examples_so_far=None):
-    """ [Figure 19.2]
+    """
+    [Figure 19.2]
     The hypothesis is a list of dictionaries, with each dictionary representing
     a disjunction."""
     if examples_so_far is None:
@@ -124,7 +125,8 @@ def add_or(examples_so_far, h):
 
 
 def version_space_learning(examples):
-    """ [Figure 19.3]
+    """
+    [Figure 19.3]
     The version space is a list of hypotheses, which in turn are a list
     of dictionaries/disjunctions."""
     V = all_hypotheses(examples)
@@ -241,7 +243,7 @@ def consistent_det(A, E):
 # ______________________________________________________________________________
 
 
-class FOIL_container(FolKB):
+class FOILContainer(FolKB):
     """Hold the kb and other necessary elements required by FOIL."""
 
     def __init__(self, clauses=None):
@@ -255,7 +257,7 @@ def tell(self, sentence):
             self.const_syms.update(constant_symbols(sentence))
             self.pred_syms.update(predicate_symbols(sentence))
         else:
-            raise Exception("Not a definite clause: {}".format(sentence))
+            raise Exception('Not a definite clause: {}'.format(sentence))
 
     def foil(self, examples, target):
         """Learn a list of first-order horn clauses
@@ -280,15 +282,14 @@ def new_clause(self, examples, target):
         The horn clause is specified as [consequent, list of antecedents]
         Return value is the tuple (horn_clause, extended_positive_examples)."""
         clause = [target, []]
-        # [positive_examples, negative_examples]
         extended_examples = examples
         while extended_examples[1]:
             l = self.choose_literal(self.new_literals(clause), extended_examples)
             clause[1].append(l)
             extended_examples = [sum([list(self.extend_example(example, l)) for example in
                                       extended_examples[i]], []) for i in range(2)]
 
-        return (clause, extended_examples[0])
+        return clause, extended_examples[0]
 
     def extend_example(self, example, literal):
         """Generate extended examples which satisfy the literal."""
@@ -344,9 +345,8 @@ def gain(self, l, examples):
             represents = lambda d: all(d[x] == example[x] for x in example)
             if any(represents(l_) for l_ in post_pos):
                 T += 1
-        value = T * (
-                log(len(post_pos) / (len(post_pos) + len(post_neg)) + 1e-12, 2) - log(pre_pos / (pre_pos + pre_neg),
-                                                                                      2))
+        value = T * (log(len(post_pos) / (len(post_pos) + len(post_neg)) + 1e-12, 2) -
+                     log(pre_pos / (pre_pos + pre_neg), 2))
         return value
 
     def update_examples(self, target, examples, extended_examples):
@@ -411,12 +411,12 @@ def guess_value(e, h):
 
 
 def is_consistent(e, h):
-    return e["GOAL"] == guess_value(e, h)
+    return e['GOAL'] == guess_value(e, h)
 
 
 def false_positive(e, h):
-    return guess_value(e, h) and not e["GOAL"]
+    return guess_value(e, h) and not e['GOAL']
 
 
 def false_negative(e, h):
-    return e["GOAL"] and not guess_value(e, h)
+    return e['GOAL'] and not guess_value(e, h)

games.py

@@ -8,7 +8,7 @@
 from statistics import mean, stdev
 
 from probabilistic_learning import NaiveBayesLearner
-from utils import (remove_all, unique, mode, argmax, argmax_random_tie, isclose, dotproduct, vector_add,
+from utils import (remove_all, unique, mode, argmax, argmax_random_tie, isclose, dot_product, vector_add,
                    scalar_vector_product, weighted_sample_with_replacement, num_or_str, normalize, clip, sigmoid,
                    print_table, open_data, sigmoid_derivative, probability, relu, relu_derivative, tanh,
                    tanh_derivative, leaky_relu_derivative, elu, elu_derivative, mean_boolean_error, random_weights)
@@ -536,17 +536,17 @@ def LinearLearner(dataset, learning_rate=0.01, epochs=100):
         # pass over all examples
         for example in examples:
             x = [1] + example
-            y = dotproduct(w, x)
+            y = dot_product(w, x)
             t = example[idx_t]
             err.append(t - y)
 
         # update weights
         for i in range(len(w)):
-            w[i] = w[i] + learning_rate * (dotproduct(err, X_col[i]) / num_examples)
+            w[i] = w[i] + learning_rate * (dot_product(err, X_col[i]) / num_examples)
 
     def predict(example):
         x = [1] + example
-        return dotproduct(w, x)
+        return dot_product(w, x)
 
     return predict
 
@@ -578,19 +578,19 @@ def LogisticLinearLeaner(dataset, learning_rate=0.01, epochs=100):
         # pass over all examples
         for example in examples:
             x = [1] + example
-            y = sigmoid(dotproduct(w, x))
+            y = sigmoid(dot_product(w, x))
             h.append(sigmoid_derivative(y))
             t = example[idx_t]
             err.append(t - y)
 
         # update weights
         for i in range(len(w)):
             buffer = [x * y for x, y in zip(err, h)]
-            w[i] = w[i] + learning_rate * (dotproduct(buffer, X_col[i]) / num_examples)
+            w[i] = w[i] + learning_rate * (dot_product(buffer, X_col[i]) / num_examples)
 
     def predict(example):
         x = [1] + example
-        return sigmoid(dotproduct(w, x))
+        return sigmoid(dot_product(w, x))
 
     return predict
 
@@ -624,7 +624,7 @@ def predict(example):
         for layer in learned_net[1:]:
             for node in layer:
                 inc = [n.value for n in node.inputs]
-                in_val = dotproduct(inc, node.weights)
+                in_val = dot_product(inc, node.weights)
                 node.value = node.activation(in_val)
 
         # hypothesis
@@ -672,7 +672,7 @@ def BackPropagationLearner(dataset, net, learning_rate, epochs, activation=sigmo
             for layer in net[1:]:
                 for node in layer:
                     inc = [n.value for n in node.inputs]
-                    in_val = dotproduct(inc, node.weights)
+                    in_val = dot_product(inc, node.weights)
                     node.value = node.activation(in_val)
 
             # initialize delta
@@ -706,19 +706,19 @@ def BackPropagationLearner(dataset, net, learning_rate, epochs, activation=sigmo
                 w = [[node.weights[k] for node in nx_layer] for k in range(h_units)]
 
                 if activation == sigmoid:
-                    delta[i] = [sigmoid_derivative(layer[j].value) * dotproduct(w[j], delta[i + 1])
+                    delta[i] = [sigmoid_derivative(layer[j].value) * dot_product(w[j], delta[i + 1])
                                 for j in range(h_units)]
                 elif activation == relu:
-                    delta[i] = [relu_derivative(layer[j].value) * dotproduct(w[j], delta[i + 1])
+                    delta[i] = [relu_derivative(layer[j].value) * dot_product(w[j], delta[i + 1])
                                 for j in range(h_units)]
                 elif activation == tanh:
-                    delta[i] = [tanh_derivative(layer[j].value) * dotproduct(w[j], delta[i + 1])
+                    delta[i] = [tanh_derivative(layer[j].value) * dot_product(w[j], delta[i + 1])
                                 for j in range(h_units)]
                 elif activation == elu:
-                    delta[i] = [elu_derivative(layer[j].value) * dotproduct(w[j], delta[i + 1])
+                    delta[i] = [elu_derivative(layer[j].value) * dot_product(w[j], delta[i + 1])
                                 for j in range(h_units)]
                 else:
-                    delta[i] = [leaky_relu_derivative(layer[j].value) * dotproduct(w[j], delta[i + 1])
+                    delta[i] = [leaky_relu_derivative(layer[j].value) * dot_product(w[j], delta[i + 1])
                                 for j in range(h_units)]
 
             # update weights
@@ -746,7 +746,7 @@ def predict(example):
 
         # forward pass
         for node in o_nodes:
-            in_val = dotproduct(example, node.weights)
+            in_val = dot_product(example, node.weights)
             node.value = node.activation(in_val)
 
         # hypothesis

games4e.py

@@ -1,4 +1,4 @@
-"""Learning from examples. (Chapters 18)"""
+"""Learning from examples (Chapters 18)"""
 
 import copy
 import heapq
@@ -9,9 +9,9 @@
 
 from probabilistic_learning import NaiveBayesLearner
 from utils import sigmoid, sigmoid_derivative
-from utils4e import (remove_all, unique, mode, argmax_random_tie, isclose, dotproduct, weighted_sample_with_replacement,
-                     num_or_str, normalize, clip, print_table, open_data, probability, random_weights,
-                     mean_boolean_error)
+from utils4e import (remove_all, unique, mode, argmax_random_tie, isclose, dot_product,
+                     weighted_sample_with_replacement, num_or_str, normalize, clip, print_table, open_data, probability,
+                     random_weights, mean_boolean_error)
 
 
 class DataSet:
@@ -531,17 +531,17 @@ def LinearLearner(dataset, learning_rate=0.01, epochs=100):
         # pass over all examples
         for example in examples:
             x = [1] + example
-            y = dotproduct(w, x)
+            y = dot_product(w, x)
             t = example[idx_t]
             err.append(t - y)
 
         # update weights
         for i in range(len(w)):
-            w[i] = w[i] + learning_rate * (dotproduct(err, X_col[i]) / num_examples)
+            w[i] = w[i] + learning_rate * (dot_product(err, X_col[i]) / num_examples)
 
     def predict(example):
         x = [1] + example
-        return dotproduct(w, x)
+        return dot_product(w, x)
 
     return predict
 
@@ -573,19 +573,19 @@ def LogisticLinearLeaner(dataset, learning_rate=0.01, epochs=100):
         # pass over all examples
         for example in examples:
             x = [1] + example
-            y = sigmoid(dotproduct(w, x))
+            y = sigmoid(dot_product(w, x))
             h.append(sigmoid_derivative(y))
             t = example[idx_t]
             err.append(t - y)
 
         # update weights
         for i in range(len(w)):
             buffer = [x * y for x, y in zip(err, h)]
-            w[i] = w[i] + learning_rate * (dotproduct(buffer, X_col[i]) / num_examples)
+            w[i] = w[i] + learning_rate * (dot_product(buffer, X_col[i]) / num_examples)
 
     def predict(example):
         x = [1] + example
-        return sigmoid(dotproduct(w, x))
+        return sigmoid(dot_product(w, x))
 
     return predict