TD 1 - 14 septembre 2015

Introduction Python, numpy, matplotlib

tao.lri.fr/tiki-index.php?page=Courses : Module Apprentissage, TD 1

Python est un langage :

  • interprété : les instructions sont lues et traduites en langage machine ligne à ligne.
  • non typé : Il n'est pas utile de préciser le type des variables : il sera directement assigné par l'interpréteur.

C'est un langage dont l'usage est extrêmement répandu dans les milieux académique et industriel.

IDE utilisé : IPython notebook Après avoir téléchargé Anaconda (distribution python incluant les package populaires:http://continuum.io/downloads) $ ipython notebook

I - fonctions de bases

1) List et slice

In [43]:
l = [10,11,12,13,14,15]
l[0]
Out[43]:
10
In [44]:
l.append(16) # ajoute un élément en fin de liste
l.count(14) # compte le nombre d'élements (=14)
Out[44]:
1
In [45]:
l[3:7] #slice entre 3 inclus et 7 exlus
Out[45]:
[13, 14, 15, 16]
In [46]:
s = 0
for i in l:
    s = s + i # une tabulation (ou 4 espaces) à l'intérieur d'une boucle ou d'une fonctions
s
Out[46]:
91
In [47]:
def my_function(x):
    
    return x[0] + x[2]
In [48]:
my_function(l)
Out[48]:
22

2) Array (tableau)

1 dimension

In [49]:
import numpy as np # import la librairie numpy (calcul scientifique) 
# Doc : http://docs.scipy.org/doc/numpy/reference/
In [50]:
a = np.arange(5,15)
a
Out[50]:
array([ 5,  6,  7,  8,  9, 10, 11, 12, 13, 14])
In [51]:
a[0]
Out[51]:
5
In [52]:
a[(a%2==0)] # rend les termes paire
Out[52]:
array([ 6,  8, 10, 12, 14])
In [53]:
b = np.arange(0,1,0.1)
b
Out[53]:
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])
In [54]:
b[[2,3,4]] # rend les élements de positions 2,3 et 4
Out[54]:
array([ 0.2,  0.3,  0.4])
In [55]:
a + b # somme terme à terme
Out[55]:
array([  5. ,   6.1,   7.2,   8.3,   9.4,  10.5,  11.6,  12.7,  13.8,  14.9])
In [56]:
b * 3
Out[56]:
array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8,  2.1,  2.4,  2.7])

2 dimension

In [57]:
A = np.array([[0,1,2],[3,4,5],[6,7,8]])
print(A)
[[0 1 2]
 [3 4 5]
 [6 7 8]]
In [58]:
I = np.eye(3,3)
I
Out[58]:
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])
In [59]:
Z = np.zeros((5,2))
O = np.ones((5,2))
R = np.random.rand(5,2)
In [60]:
(Z + 1) * 3 
Out[60]:
array([[ 3.,  3.],
       [ 3.,  3.],
       [ 3.,  3.],
       [ 3.,  3.],
       [ 3.,  3.]])
In [61]:
R * Z # produit terme à terme
Out[61]:
array([[ 0.,  0.],
       [ 0.,  0.],
       [ 0.,  0.],
       [ 0.,  0.],
       [ 0.,  0.]])
In [62]:
v = np.array([0,1,10])
np.dot(A,v) #produit matriciel
Out[62]:
array([21, 54, 87])

3) plot et scatter

In [63]:
import matplotlib.pyplot as plt # librairie pour afficher les graphs.
# Doc : http://matplotlib.org/gallery.html, http://matplotlib.org/api/pyplot_api.html
%matplotlib inline 
# Affiche dans la fenêtre courante.
In [64]:
x = np.arange(-10,10,0.1)
y = np.cos(x)
plt.plot(x,y)
plt.title('cosinus')
plt.xlabel('abscisses')
plt.ylabel('ordonnées')
Out[64]:
<matplotlib.text.Text at 0x7f3dc1b6f898>
In [65]:
x = np.random.rand(100) * 10
y = np.random.rand(100) + 10
plt.scatter(x,y)
plt.scatter(np.mean(x),np.mean(y), c = 'red', s=100)
Out[65]:
<matplotlib.collections.PathCollection at 0x7f3dc1b3bcf8>

II - Exercices

1) Produit scalaire

On rappelle que, pour $ x = (x_1,\ldots,x_n)$ et $y = (y_1,\ldots,y_n)$ dans $\mathbb{R}^n$, on définit le produit scalaire de $x$ et $y$ par $ = \sum_{i=1}^n x_i y_i = x y^T$.

Écrire deux fonctions prenant en entrée deux vecteurs (list ou array) :

  • La première devra calculer leur produit scalaire comme produit matriciel
  • La seconde devra calculer leur produit scalaire de manière itérative. ($len$ permet de connaitre la longueur d'une liste ou d'un tableau 1D).

Tester le temps de calcul de chaque méthode ( %timeit my_function(x,y) )

2) Approximation de $\frac{\pi}{4}$ par Monte-Carlo

On désire approximer $\frac{\pi}{4}$ par méthode de Monte-Carlo. Un point tiré uniformément dans $[0, 1] \times [0, 1]$ est dans le quart de disque vérifiant $x^2 + y^2 \leq 1$ avec probabilité $\frac{\pi}{4}$.

a) Écrire une fonction qui :

  • prend en argument un entier $N$
  • tire $N$ points indépendemment et uniformément sur $[0, 1] \times [0, 1]$
  • affiche en rouge, avec la commande $plt.scatter$, les $n_1$ points dans le quart de disque de rayon 1
  • affiche en bleu les autres points
  • retourne le rapport $\frac{n_1}{N}$

b) Afficher l'évolution de $\frac{n_1}{N}$ en fonction de $N$.

III - Scikit-learn

Machine Learning in Python

http://scikit-learn.org/

In [66]:
import sklearn # if not installed : pip install sklearn
In [67]:
X = [[0, 0], [1, 1]]
y = [0, 1]
# X : n_samples x n_features - data
# y : n_samples - labels
In [68]:
from sklearn import tree
#http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html
clf = tree.DecisionTreeClassifier() # clf : une instance de la classe 'DecisionTreeClassifier'
In [69]:
clf = clf.fit(X, y) # fit : s'entraine sur les données
In [70]:
clf.predict([[2., 2.]]) # predict : prédit le label d'une nouvelle donnée
Out[70]:
array([1])
In [71]:
clf.predict_proba([[2., 2.]]) # predict_proba : doone la distribution de probabilité
Out[71]:
array([[ 0.,  1.]])
In [72]:
clf.score(X,y) # évalue le score du classifier
# score = list(clf.predict(X) == y).count(True) / len(y)
Out[72]:
1.0
In [73]:
clf.feature_importances_
Out[73]:
array([ 1.,  0.])

a) Regression

data : 1 dimension

target : scalaire

In [74]:
# Create a random dataset
rng = np.random.RandomState(1)
X = np.sort(5 * rng.rand(80, 1), axis=0)
y = np.sin(X).ravel()
y[::5] += 3 * (0.5 - rng.rand(16))
In [75]:
from sklearn import tree

clf_1 = tree.DecisionTreeRegressor()
clf_1.fit(X, y)
score_train = clf_1.score(X,y)

# Predict
X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
y_1 = clf_1.predict(X_test)
score_test = clf_1.score(X_test,np.sin(X_test))

# Plot the results
plt.figure()
plt.scatter(X, y, c="k", label="data")
plt.plot(X_test, y_1, c="g", label="", linewidth=2)
plt.xlabel("data")
plt.ylabel("target")
plt.title("Decision Tree Regression. score train = " + str(np.round(score_train,2)) +\
        " score test = " + str(np.round(score_test,2)))
plt.legend()
plt.show()
In [76]:
list_score_test = []
list_score_train = []
for max_depth in np.arange(1,10):
    
    # Fit regression model
    clf_1 = tree.DecisionTreeRegressor(max_depth=max_depth)
    clf_1.fit(X, y)
    score_train = clf_1.score(X,y)
    list_score_train.append(score_train)

    # Predict
    X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
    y_1 = clf_1.predict(X_test)
    score_test = clf_1.score(X_test,np.sin(X_test))
    list_score_test.append(score_test)

    # Plot the results
    plt.figure()
    plt.scatter(X, y, c="k", label="data")
    plt.plot(X_test, y_1, c="g", label="max_depth="+str(max_depth), linewidth=2)
    plt.xlabel("data")
    plt.ylabel("target")
    plt.title("Decision Tree Regression. score train = " + str(np.round(score_train,2)) +\
            " score test = " + str(np.round(score_test,2)))
    plt.legend()
    plt.show()
In [77]:
plt.plot(list_score_train, label = 'train set')
plt.plot(list_score_test, label = 'test set')
plt.xlabel('max_depth')
plt.ylabel('score')
plt.legend()
Out[77]:
<matplotlib.legend.Legend at 0x7f3dc1d94f60>

b) Classification

In [78]:
# Make data
rng = np.random.RandomState(13)
d1 = np.asarray(((np.arange(10) + rng.rand(10),np.arange(10)+ rng.rand(10)))).T
d2 = np.asarray(((np.arange(3,13)+ rng.rand(10),np.arange(10)+ rng.rand(10)))).T
X = np.vstack((d1,d2))
y = [0] * d1.shape[0] + [1] * d2.shape[0]
plt.scatter(X[:,0],X[:,1], c = y, s = 50)
Out[78]:
<matplotlib.collections.PathCollection at 0x7f3dc1f5f780>
In [79]:
# Ne pas s'attarder sur cette fonction pour le moment.
def plot_boundary(X, label = None):
    # Affiche la carte avec les zones de chaque catégorie
    
    plt.figure()
    plot_step = 0.02
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step),
                         np.arange(y_min, y_max, plot_step))
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    cs = plt.contourf(xx, yy, Z, cmap=plt.cm.Paired)
    plt.scatter(X[:,0],X[:,1], c = label)
In [80]:
# fait varier max_depth
for max_depth in np.arange(1,10):
    clf = tree.DecisionTreeClassifier(max_depth=max_depth)
    clf = clf.fit(X, y)
    plot_boundary(X,y)
    plt.title('score = ' + str(clf.score(X,y)))
    #print(clf.score(X,y))
    if clf.score(X,y) == 1.:
        break
In [90]:
clf  =tree.DecisionTreeClassifier(criterion='gini', splitter='best', max_depth=None, min_samples_split=2,\
                            min_samples_leaf=1,\
                            max_features=None, random_state=None, max_leaf_nodes=None)
In [ ]:
 
In [ ]:
 
In [ ]:
 
In [ ]:
 

Autre data

In [81]:
from sklearn.datasets import make_moons
X,y = make_moons(n_samples=300, noise=.1, random_state=12)
/home/thomas/anaconda3/lib/python3.4/site-packages/sklearn/datasets/samples_generator.py:612: DeprecationWarning: using a non-integer number instead of an integer will result in an error in the future
  y = np.hstack([np.zeros(n_samples_in, dtype=np.intp),
In [82]:
plt.scatter(X[:,0],X[:,1], c = y, s=90)
Out[82]:
<matplotlib.collections.PathCollection at 0x7f3dc0d18780>
In [83]:
# fait varier max_depth
for max_depth in np.arange(1,10):
    clf = tree.DecisionTreeClassifier(max_depth=max_depth)
    clf = clf.fit(X, y)
    plot_boundary(X,y)
    plt.title('score = ' + str(clf.score(X,y)))
    #print(clf.score(X,y))
    if clf.score(X,y) == 1.:
        break

Multi class

In [ ]:
 
In [84]:
# Make data
rng = np.random.RandomState(13)
d1 = np.asarray(((np.arange(10) + rng.rand(10),np.arange(10)+ rng.rand(10)))).T
d2 = np.asarray(((np.arange(7,17)+ rng.rand(10),np.arange(10)+ rng.rand(10)))).T
d3 = np.asarray(((np.arange(3,13)+ rng.rand(10),np.arange(10)+ rng.rand(10)))).T
X = np.vstack((d1,d2,d3))
y = [0] * d1.shape[0] + [1] * d2.shape[0] + [2] * d3.shape[0]
plt.scatter(X[:,0],X[:,1], c = y, s = 50)
Out[84]:
<matplotlib.collections.PathCollection at 0x7f3dc1a94588>
In [85]:
# fait varier max_depth
for max_depth in np.arange(1,10):
    clf = tree.DecisionTreeClassifier(max_depth=max_depth)
    clf = clf.fit(X, y)
    plot_boundary(X,y)
    plt.title('score = ' + str(clf.score(X,y)))
    #print(clf.score(X,y))
    if clf.score(X,y) == 1.:
        break
In [ ]:
 
In [ ]: