add quick and dirty implementation of mini-batches

mlp.py

@@ -149,6 +149,10 @@ class MultiLayerPerceptron(object):
         assert(len(self._g) == len(self._W))
         assert(len(self._g) == len(self._b))
         assert(len(self._g) == len(self._n))
+        self._bacthes_x = []
+        self._bacthes_y = []
+        self._current_batch = 0
+        self._nb_batches = 0
 
     def init_random_weights(self, use_formula=False, w_rand_factor=1):
         """Initialize randomly weights using a factor or using some formula
@@ -274,6 +278,29 @@ class MultiLayerPerceptron(object):
         self.set_all_input_examples(X, m)
         self.set_all_expected_output_examples(Y, m)
 
+    def set_batches(self, batches):
+        """Set the batch for training. dimensions are nb_minibatches, exemples (in/out->2), minibatch lengths
+        """
+        self._batch_x = []
+        self._batch_y = []
+        self._batch_m = []
+        for b in batches:
+            self._batch_x.append(np.array(b[0]).T)
+            self._batch_y.append(np.array(b[1]).T)
+            self._batch_m.append(len(b[0]))
+        self._current_batch = 0
+        self._nb_batches = len(batches)
+
+    def get_next_batch(self):
+        """Get the current mini-bacth and update to next the current. If reaches the end then go back to first.
+        """
+        X = self._batch_x[self._current_batch]
+        Y = self._batch_y[self._current_batch]
+        self._current_batch += 1
+        if self._current_batch >= self._nb_batches:
+            self._current_batch = 0
+        return X, Y
+
     def prepare(self, X=None, m=None, force=False):
         """Prepare network for propagation"""
         if X is not None:
@@ -370,7 +397,7 @@ class MultiLayerPerceptron(object):
             J += self._lambda_regul/(2*m) * wnorms
         return J
 
-    def back_propagation(self, get_cost_function=False):
+    def back_propagation(self):
         """Back propagation"""
         L = self._L
         m = self._m
@@ -454,6 +481,45 @@ class MultiLayerPerceptron(object):
             mp.show()
         return {"iterations": nb_iter, "cost_function": J}
 
+    def minimize_cost_batches(self, min_cost, max_iter=100000, alpha=None, plot=False):
+        """Propagate forward then backward in loop while minimizing the cost function.
+
+        :param min_cost: cost function value to reach in order to stop algo.
+        :param max_iter: maximum number of iterations to reach min cost befor stoping algo. (Default 100000).
+        :param alpha: learning rate, if None use the instance alpha value. Default None.
+        :param plot: if True will plot the graph cost function depending on iteration
+
+        """
+        nb_iter = 0
+        if alpha is None:
+            alpha = self._alpha
+        if plot:
+            y=[]
+            x=[]
+        for i in range(max_iter):
+            nb_iter = i + 1
+            tot_j = 0
+            for t in range(self._nb_batches):
+                X, Y = self.get_next_batch()
+                self.set_all_training_examples(X, Y, self._batch_m[t])
+                self.prepare()
+                # forward propagation
+                self.propagate()
+                # compute cost function
+                J = self.compute_cost_function()
+                # back propagation
+                self.back_propagation()
+                tot_j += J / self._nb_batches
+            if plot:
+                y.append(tot_j)
+                x.append(nb_iter)
+            #if tot_j <= min_cost:
+            #    break
+        if mp and plot:
+            mp.plot(x,y)
+            mp.show()
+        return {"iterations": nb_iter, "cost_function": tot_j}
+
     def learning(self, X, Y, m, min_cost=0.05, max_iter=100000, alpha=None, plot=False):
         """Tune parameters in order to learn examples by propagate and backpropagate.
 
@@ -470,6 +536,19 @@ class MultiLayerPerceptron(object):
         res = self.minimize_cost(min_cost, max_iter, alpha, plot)
         return res
 
+    def learning_batches(self, min_cost=0.05, max_iter=100000, alpha=None, plot=False):
+        """Tune parameters in order to learn examples by propagate and backpropagate.
+
+        :param X: the inputs training examples
+        :param Y: the expected outputs training examples
+        :param m: the number of examples
+        :param min_cost: cost function value to reach in order to stop algo. Default 0.0.5
+        :param max_iter: maximum number of iterations to reach min cost befor stoping algo. (Default 100000).
+        :param alpha: learning rate, if None use the instance alpha value. Default None.
+
+        """
+        res = self.minimize_cost_batches(min_cost, max_iter, alpha, plot)
+        return res
 
     def get_output(self):
         return self._A[self._L]