Cours de Deep Learning, Ecole Centrale, 3eme année, Option OMIS

Slides de presentations des UES (12/09/2016)

Supports de cours et sujets de TP sur machine

Semaine 5

Semaine 4

Semaine 3

Semaine 2

Semaine 1

Semaine 6

En utilisant le script expes.py exploitant les codes mlp_ta et sparse_ae vous devez être capables d'obtenir des performances de l'ordre de 98% en test sur MNIST.
En utilisant le code du notebook vous pouvez récupérer les prédictions d'un réseau appris avec caffe.

Semaine 5

Semaine 4

Utilisez le script script_ta_mlp.py qui charge la classe MLP de mlp_ta_base.py pour apprendre un MLP sur les données MNIST.
Avec le réglage courant (une couche cachée de 100 neurones, une fonction d'activation sigmoide, un learning rate initial de 0.05)
vous devriez obtenir de l"ordre de 98% de reconnaissance sur la base d'apprentissage et 97% sur la base de test

Semaine 3

Le fichier sparse_aae.py contient le codes des sparse autoencoder avec une optimisation fit par LBFGS, algo d'optimisation d'ordre 2.
Le fichier GridSearchCV_SAE.py permet d'apprendre par cross validation un pipeline constitué d'un sparse AE suivi d'un SVM.
Il est possible après optimisation de récupérer l'autoencodeur uniquement.

Semaine 2

Semaine 1

"""AutoEncoders """

  1. Main author:

import time

import numpy as np

import pylab as pl

import numpy import math import time import scipy.io import scipy.optimize import matplotlib.pyplot

from sklearn.base import BaseEstimator from sklearn.base import TransformerMixin

  1. from sklearn.externals.six.moves import xrange

from sklearn.utils import check_arrays from sklearn.utils import check_random_state from sklearn.utils import gen_even_slices from sklearn.utils.extmath import safe_sparse_dot

  1. from sklearn.utils.extmath import logistic_sigmoid

class SparseAutoEncoder(BaseEstimator, TransformerMixin):

    """Autoencoder implementation

    Parameters
    ----------
    Nb_hiddens : int, optional
        Number of hidden units.

    learning_rate : float, optional
        The learning rate for weight updates. It is *highly* recommended
        to tune this hyper-parameter. Reasonable values are in the
        10**[0., -3.] range.

    n_iter : int, optional
        Number of iterations/sweeps over the training dataset to perform
        during training.

    verbose : bool, optional
        The verbosity level.
    """

    def __init__(self, Nb_hiddens=20, learning_rate=0.001, batch_size=10, n_iter=10, verbose=False,  
                 beta = 0.1, Lambda = 0.001, rho =0.05):
        self.Nb_hiddens = Nb_hiddens
        self.learning_rate = learning_rate
        self.learning_rate_initial = learning_rate
        self.batch_size = batch_size
        self.n_iter = n_iter
        self.verbose = verbose
        self.Lambda= Lambda
        self.rho = rho
        self.beta = beta

    def sigmoid(self, x):
        return (1 / (1 + np.exp(-x)))
  1. fonctions pour dataset entier (necessaires pour sparse autoencoders)
    def Fwd_2_Hid_TS(self, X): #TS stands for the whole Training Set
        # X is assumed matrix with one sample per column
        H = np.dot(self.W_Hids, X) + self.WBias_hids
        H = self.sigmoid(H)
        return H

    def Fwd_2_Out_TS(self, H):
        O = np.dot(self.W_Outs,H) + self.WBias_outs
        O = self.sigmoid(O)
        return O

    def predict_TS(self, X):
        H = self.Fwd_2_Hid_TS(X)
        O = self.Fwd_2_Out_TS(H)
        return self.sigmoid(O)

    def predict_MeanActivHid_TS(self, X):
        H = self.Fwd_2_Hid_TS(X)
        rho_cap = np.sum(H, axis = 1) / X.shape[1]
        return H, rho_cap

    def compute_err_TS(self, X):
        O = self.predict_TS(X)
        #print "O shape \n", O.shape
        #print X.shape
        diff = self.predict_TS(X) - X
        return 0.5 * np.sum(np.multiply(diff, diff)) / (X.shape[1] * X.shape[0])

    def compute_grad_TS(self, X):

        O = self.Fwd_2_Out_TS(H)
...
       return W1_grad, W2_grad, b1_grad, b2_grad

    def maj(self, W1_grad, W2_grad, b1_grad, b2_grad):
        self.W_Hids = self.W_Hids - self.learning_rate * W1_grad  
        self.W_Outs = self.W_Outs - self.learning_rate * W2_grad  
        self.WBias_hids = self.WBias_hids - self.learning_rate * b1_grad  
        self.WBias_outs = self.WBias_outs - self.learning_rate * b2_grad  

    def init_weights(self, nb_inputs):
        self.nb_inputs = nb_inputs
        self.W_Hids = np.asarray(np.random.normal(0, 1/(np.power(self.Nb_hiddens,0.5)*np.power(nb_inputs,0.5)), (self.Nb_hiddens, nb_inputs)), order='fortran')
        self.W_Outs = np.asarray(np.random.normal(0, 1/(np.power(self.Nb_hiddens,0.5)*np.power(nb_inputs,0.5)), (nb_inputs, self.Nb_hiddens)), order='fortran') #self.W_Hids.T
        self.WBias_hids = np.zeros((self.Nb_hiddens, 1))
        self.WBias_outs = np.zeros((nb_inputs, 1))


        return 1



    def fit(self, X):
        n_samples = X.shape[0]
        i_rand = np.random.permutation(n_samples)
        X = X[i_rand,]
        verbose = self.verbose

        err_old = 1000000000
        for iteration in range(self.n_iter):

            print "Iteration ", iteration
            if verbose:
                begin = time.time()

            W1_grad, W2_grad, b1_grad, b2_grad = self.compute_grad_TS(X)
            self.maj(W1_grad, W2_grad, b1_grad, b2_grad)
            err = self.compute_err_TS(X)
            self.learning_rate = self.learning_rate_initial / (1+ (self.learning_rate_initial * self.Lambda * iteration))
            print " : Iteration -> Erreur %s \n" %  err
            print " Espilon ", self.learning_rate

        return self



    def plot_features_appris(self):
        nb_hiddens = self.Nb_hiddens
        g = self.W_Hids
        taille_filtre = np.rint(np.power(g.shape[1],0.5))
        nblig = np.floor(np.power(nb_hiddens,0.5))
        nbcol = np.floor(np.power(nb_hiddens,0.5))+1

        for i in range(nb_hiddens):
            pl.subplot(nblig, nbcol, i + 1)
            pl.axis('off')
            filtre = g[i,].reshape(taille_filtre, taille_filtre)   / (np.sum(g[i,] * g[i,] )) 
            pl.imshow(filtre, cmap = pl.get_cmap('gray'), vmin = -1, vmax = 1)
        pl.show()

        return;

Poste de MC en Informatique à l'ECM : Données massives / apprentissage profond (intégration au laboratoire LIF) Fiche Galaxie Δ

 Projets LIF ECM Δ

Artifical Intelligence : Un programme bat les professionnels au Poker

Conférence Francophone d'Apprentissage Automatique (CAP 2016): 04-07 Juillet 2016

Journée du PR2I Big data d'AMU sur le Traitement de Données massives

Jeudi 15 Octobre de 8h30 à 14h sur le site Saint Charles (Salles de conférences 1 et 2)

Annonce de a journée

Plus d'information