aimacode · BesanHalwa · Mar 25, 2017 · Mar 25, 2017 · Apr 3, 2017 · Apr 3, 2017
diff --git a/images/Crossover.png b/images/Crossover.png
diff --git a/images/comparision.PNG b/images/comparision.PNG
diff --git a/images/mutation.png b/images/mutation.png
diff --git a/learning.py b/learning.py
@@ -12,39 +12,45 @@
 import random
 
 from statistics import mean
-from collections import defaultdict, Counter
+from collections import defaultdict
 
 # ______________________________________________________________________________
 
-def rms_error(predictions, targets):
-    return math.sqrt(ms_error(predictions, targets))
 
+def euclidean_distance(X, Y):
+    return math.sqrt(sum([(x - y)**2 for x, y in zip(X, Y)]))
 
-def ms_error(predictions, targets):
-    return mean([(p - t)**2 for p, t in zip(predictions, targets)])
 
+def rms_error(X, Y):
+    return math.sqrt(ms_error(X, Y))
 
-def mean_error(predictions, targets):
-    return mean([abs(p - t) for p, t in zip(predictions, targets)])
 
+def ms_error(X, Y):
+    return mean([(x - y)**2 for x, y in zip(X, Y)])
 
-def manhattan_distance(predictions, targets):
-    return sum([abs(p - t) for p, t in zip(predictions, targets)])
 
+def mean_error(X, Y):
+    return mean([abs(x - y) for x, y in zip(X, Y)])
 
-def mean_boolean_error(predictions, targets):
-    return mean(int(p != t) for p, t in zip(predictions, targets))
 
-def hamming_distance(predictions, targets):
-    return sum(p != t for p, t in zip(predictions, targets))
+def manhattan_distance(X, Y):
+    return sum([abs(x - y) for x, y in zip(X, Y)])
+
+
+def mean_boolean_error(X, Y):
+    return mean(int(x != y) for x, y in zip(X, Y))
+
+
+def hamming_distance(X, Y):
+    return sum(x != y for x, y in zip(X, Y))
 
 # ______________________________________________________________________________
 
 
 class DataSet:
-    """A data set for a machine learning problem.  It has the following fields:
+    """A data set for a machine learning problem. It has the following fields:
 
-    d.examples   A list of examples.  Each one is a list of attribute values.
+    d.examples   A list of examples. Each one is a list of attribute values.
     d.attrs      A list of integers to index into an example, so example[attr]
                  gives a value. Normally the same as range(len(d.examples[0])).
     d.attrnames  Optional list of mnemonic names for corresponding attrs.
@@ -60,14 +66,16 @@ class DataSet:
                  since that can handle any field types.
     d.name       Name of the data set (for output display only).
     d.source     URL or other source where the data came from.
+    d.exclude    A list of attribute indexes to exclude from d.inputs. Elements
+                 of this list can either be integers (attrs) or attrnames.
 
     Normally, you call the constructor and you're done; then you just
     access fields like d.examples and d.target and d.inputs."""
 
     def __init__(self, examples=None, attrs=None, attrnames=None, target=-1,
                  inputs=None, values=None, distance=mean_boolean_error,
                  name='', source='', exclude=()):
-        """Accepts any of DataSet's fields.  Examples can also be a
+        """Accepts any of DataSet's fields. Examples can also be a
         string or file from which to parse examples using parse_csv.
         Optional parameter: exclude, as documented in .setproblem().
         >>> DataSet(examples='1, 2, 3')
@@ -107,14 +115,14 @@ def setproblem(self, target, inputs=None, exclude=()):
         to not use in inputs. Attributes can be -n .. n, or an attrname.
         Also computes the list of possible values, if that wasn't done yet."""
         self.target = self.attrnum(target)
-        exclude = map(self.attrnum, exclude)
+        exclude = list(map(self.attrnum, exclude))
         if inputs:
             self.inputs = removeall(self.target, inputs)
         else:
             self.inputs = [a for a in self.attrs
                            if a != self.target and a not in exclude]
         if not self.values:
-            self.values = list(map(unique, zip(*self.examples)))
+            self.update_values()
         self.check_me()
 
     def check_me(self):
@@ -149,22 +157,26 @@ def attrnum(self, attr):
         else:
             return attr
 
+    def update_values(self):
+        self.values = list(map(unique, zip(*self.examples)))
+
     def sanitize(self, example):
         """Return a copy of example, with non-input attributes replaced by None."""
         return [attr_i if i in self.inputs else None
                 for i, attr_i in enumerate(example)]
 
-    def classes_to_numbers(self,classes=None):
+    def classes_to_numbers(self, classes=None):
         """Converts class names to numbers."""
         if not classes:
             # If classes were not given, extract them from values
             classes = sorted(self.values[self.target])
         for item in self.examples:
             item[self.target] = classes.index(item[self.target])
-            
-    def remove_examples(self,value=""):
+
+    def remove_examples(self, value=""):
         """Remove examples that contain given value."""
         self.examples = [x for x in self.examples if value not in x]
+        self.update_values()
 
     def __repr__(self):
         return '<DataSet({}): {:d} examples, {:d} attributes>'.format(
@@ -376,7 +388,7 @@ def plurality_value(examples):
 
     def count(attr, val, examples):
         """Count the number of examples that have attr = val."""
-        return sum(e[attr] == val for e in examples) #count(e[attr] == val for e in examples)
+        return sum(e[attr] == val for e in examples)
 
     def all_same_class(examples):
         """Are all these examples in the same target class?"""
@@ -635,16 +647,17 @@ def LinearLearner(dataset, learning_rate=0.01, epochs=100):
     idx_i = dataset.inputs
     idx_t = dataset.target  # As of now, dataset.target gives only one index.
     examples = dataset.examples
+    num_examples = len(examples)
 
     # X transpose
     X_col = [dataset.values[i] for i in idx_i]  # vertical columns of X
 
     # Add dummy
     ones = [1 for _ in range(len(examples))]
-    X_col = ones + X_col
+    X_col = [ones] + X_col
 
     # Initialize random weigts
-    w = [random.randrange(-0.5, 0.5) for _ in range(len(idx_i) + 1)]
+    w = [random.uniform(-0.5, 0.5) for _ in range(len(idx_i) + 1)]
 
     for epoch in range(epochs):
         err = []
@@ -657,7 +670,8 @@ def LinearLearner(dataset, learning_rate=0.01, epochs=100):
 
         # update weights
         for i in range(len(w)):
-            w[i] = w[i] - learning_rate * dotproduct(err, X_col[i])
+            w[i] = w[i] + learning_rate * (dotproduct(err, X_col[i]) / num_examples)
+
 
     def predict(example):
         x = [1] + example
@@ -754,7 +768,7 @@ def weighted_replicate(seq, weights, n):
     wholes = [int(w * n) for w in weights]
     fractions = [(w * n) % 1 for w in weights]
     return (flatten([x] * nx for x, nx in zip(seq, wholes)) +
-            weighted_sample_with_replacement(n - sum(wholes),seq, fractions, ))
+            weighted_sample_with_replacement(n - sum(wholes), seq, fractions))
 
 
 def flatten(seqs): return sum(seqs, [])
@@ -850,7 +864,7 @@ def cross_validation_wrapper(learner, dataset, k=10, trials=1):
         size += 1
 
 
-def leave_one_out(learner, dataset):
+def leave_one_out(learner, dataset, size=None):
     """Leave one out cross-validation over the dataset."""
     return cross_validation(learner, size, dataset, k=len(dataset.examples))
 
@@ -868,6 +882,7 @@ def score(learner, size):
 # ______________________________________________________________________________
 # The rest of this file gives datasets for machine learning problems.
 
+
 orings = DataSet(name='orings', target='Distressed',
                  attrnames="Rings Distressed Temp Pressure Flightnum")
 
@@ -891,6 +906,7 @@ def RestaurantDataSet(examples=None):
                    attrnames='Alternate Bar Fri/Sat Hungry Patrons Price ' +
                    'Raining Reservation Type WaitEstimate Wait')
 
+
 restaurant = RestaurantDataSet()
 
 
@@ -900,28 +916,29 @@ def T(attrname, branches):
                 for value, child in branches.items()}
     return DecisionFork(restaurant.attrnum(attrname), attrname, branches)
 
+
 """ [Figure 18.2]
 A decision tree for deciding whether to wait for a table at a hotel.
 """
 
 waiting_decision_tree = T('Patrons',
-               {'None': 'No', 'Some': 'Yes', 'Full':
-                T('WaitEstimate',
-                  {'>60': 'No', '0-10': 'Yes',
-                   '30-60':
-                   T('Alternate', {'No':
-                                   T('Reservation', {'Yes': 'Yes', 'No':
-                                                     T('Bar', {'No': 'No',
-                                                               'Yes': 'Yes'
-                                                               })}),
-                                   'Yes':
-                                   T('Fri/Sat', {'No': 'No', 'Yes': 'Yes'})}),
-                   '10-30':
-                   T('Hungry', {'No': 'Yes', 'Yes':
-                                T('Alternate',
-                                  {'No': 'Yes', 'Yes':
-                                   T('Raining', {'No': 'No', 'Yes': 'Yes'})
-                                   })})})})
+                          {'None': 'No', 'Some': 'Yes',
+                           'Full': T('WaitEstimate',
+                                     {'>60': 'No', '0-10': 'Yes',
+                                      '30-60': T('Alternate',
+                                                 {'No': T('Reservation',
+                                                          {'Yes': 'Yes',
+                                                           'No': T('Bar', {'No': 'No',
+                                                                           'Yes': 'Yes'})}),
+                                                  'Yes': T('Fri/Sat', {'No': 'No', 'Yes': 'Yes'})}
+                                                 ),
+                                      '10-30': T('Hungry',
+                                                 {'No': 'Yes',
+                                                  'Yes': T('Alternate',
+                                                           {'No': 'Yes',
+                                                            'Yes': T('Raining',
+                                                                     {'No': 'No',
+                                                                      'Yes': 'Yes'})})})})})
 
 
 def SyntheticRestaurant(n=20):