Voici une liste de commandes de base pour commencer à travailler avec Matplotlib et Numpy.

Matplotlib & Numpy

1. Charger un dataset

On charge un dataset basic (fleurs Iris très connu). On s’en sert ensuite dans l’affichage d’un nuage de points avec Matplotlib.

1
2
3
4
5
6
7
8
9
from sklearn.datasets import load_iris
iris = load_iris()

n_samples, n_features = iris.data.shape
print(n_samples)
print(n_features)

# 150
# 4

2. Afficher un nuage de points (scatter plot)

On considère travailler avec un array (150,4). Voir point 1.

1
2
# La commande qui suit permet de ne pas avoir de problème avec l'affichage de graphiques dans Jupyter Notebook 
%matplotlib inline

Affichage du scratter plot:

1
2
3
4
5
6
7
8
9
10
11
12
from matplotlib import pyplot as plt

x_index = 1
y_index = 3

# Ce formateur permet de remplacer les index des classes d'iris par leur nom dans la légende
formatter = plt.FuncFormatter(lambda i, *args: iris.target_names[int(i)])

plt.scatter(iris.data[:, x_index], iris.data[:, y_index], c=iris.target)
plt.colorbar(ticks=[0, 1, 2], format=formatter)
plt.xlabel(iris.feature_names[x_index])
plt.ylabel(iris.feature_names[y_index])

Résultat:

image

3. Manipuler des Numpy Arrays

3.1. Générer un tableau aléatoire

1
2
3
4
import numpy as np

X = np.random.random((3,5))
print(X)

Résultat:

1
2
3
[[0.74271281 0.89627097 0.95309957 0.48770972 0.3841344 ]
[0.32855405 0.11656708 0.63427992 0.51111629 0.53846283]
[0.99568791 0.44366564 0.0842925 0.12422041 0.38149375]]

3.2. Accéder à des éléments d’un numpy array

1
2
3
4
5
6
7
8
# Accéder à un seul élément
print(X[0,0])

# Accéder à une ligne
print(X[0,:]) ou print(X[0])

# Accéder à une colonne
print(X[:,0]

Résultat:

1
2
3
0.7427128108295802
[0.74271281 0.89627097 0.95309957 0.48770972 0.3841344 ]
[0.74271281 0.32855405 0.99568791]

3.3. Faire une transposée de Matrice (les lignes deviennent les colonnes)

1
print(X.T)

Résultat:

1
2
3
4
5
[[0.74271281 0.32855405 0.99568791]
[0.89627097 0.11656708 0.44366564]
[0.95309957 0.63427992 0.0842925 ]
[0.48770972 0.51111629 0.12422041]
[0.3841344 0.53846283 0.38149375]]

3.4. Faire un range sans être gêné par le dernier élement

Cette méthode permet d’obtenir un tableau à une dimension allant d’une valeur de départ à une valeur de fin avec un nombre donné d’éléments.

1
2
# la fonction linspace(premier, dernier, n) évite tout désagrément
np.linspace(1., 4., 6)

Résultat:

1
# array([ 1. ,  1.6,  2.2,  2.8,  3.4,  4. ])

3.5. Incrémenter la dimension d’un array

(Permet également de convertir explicitement un array à 1 dimension en un vecteur ligne ou vecteur colonne.)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
A = np.array([2, 0, 1, 8])
print(A)
A.shape

# [2 0 1 8]
# (4,)


B = A[np.newaxis, :]
print(B)
B.shape

# [[2 0 1 8]]
# (1, 4)

C = A[:, np.newaxis]
print(C)
C.shape

# [[2]
[0]
[1]
[8]]
# (4,1)

Alternatives:

1
2
3
4
5
6
7
np.expand_dims(A, 1)  # équivaut à A[:, np.newaxis]
np.expand_dims(A, 0) # équivaut à A[np.newaxis, :]

ou

A.reshape(A.shape + (1,)) # équivaut à A[:, np.newaxis]
A.reshape((1,) + A.shape) # équivaut à A[np.newaxis, :]

4. Manipuler des Scipy Sparse Matrices

Ces matrices sont parfois utiles lorsque le dataset est extrèmement grand (millions de features) et qu’il n’y a presque que des 0 pour un échantillon donné.

On crée une matrice avec des données aléatoires

1
2
3
4
from scipy import sparse

X = np.random.random((10, 5))
print(X)

Résultat:

1
2
3
4
5
6
7
8
9
10
[[0.74668664 0.28468523 0.31235423 0.85889384 0.44178508]
[0.42935032 0.12811469 0.10010876 0.44757517 0.85568623]
[0.52500676 0.81764407 0.32380153 0.41696393 0.46913849]
[0.38276909 0.93648265 0.19733164 0.42392672 0.75220776]
[0.71149141 0.21479105 0.93260534 0.44922132 0.1069613 ]
[0.81701 0.85721634 0.43327147 0.07404298 0.00268589]
[0.41816508 0.45835663 0.13466681 0.65741327 0.19939561]
[0.87886815 0.90599216 0.60680106 0.52665484 0.69824682]
[0.75469648 0.89312007 0.10350947 0.48109062 0.61979146]
[0.90195641 0.48118575 0.95517067 0.86300827 0.36144463]]

On fixe la majorité des éléments à 0

1
2
X[X < 0.7] = 0
print(X)

Résultat:

1
2
3
4
5
6
7
8
9
10
[[0.74668664 0.         0.         0.85889384 0.        ]
[0. 0. 0. 0. 0.85568623]
[0. 0.81764407 0. 0. 0. ]
[0. 0.93648265 0. 0. 0.75220776]
[0.71149141 0. 0.93260534 0. 0. ]
[0.81701 0.85721634 0. 0. 0. ]
[0. 0. 0. 0. 0. ]
[0.87886815 0.90599216 0. 0. 0. ]
[0.75469648 0.89312007 0. 0. 0. ]
[0.90195641 0. 0.95517067 0.86300827 0. ]]

On convertit X en une Matrice CSR (Compressed-Sparse-Row)

1
2
X_csr = sparse.csr_matrix(X)
print(X_csr)

Résultat:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
(0, 0)	0.7466866354064811
(0, 3) 0.858893836600347
(1, 4) 0.8556862339513924
(2, 1) 0.8176440715795563
(3, 1) 0.9364826540107359
(3, 4) 0.7522077587621511
(4, 0) 0.7114914132345445
(4, 2) 0.9326053405778985
(5, 0) 0.8170100021133657
(5, 1) 0.8572163407003378
(7, 0) 0.8788681533625899
(7, 1) 0.9059921645080171
(8, 0) 0.7546964834006666
(8, 1) 0.893120069181746
(9, 0) 0.9019564067395904
(9, 2) 0.9551706684658897
(9, 3) 0.8630082740227074

On rétablit la Matrice Sparse en numpy array

1
print(X_csr.toarray())

Résultat:

1
2
3
4
5
6
7
8
9
10
[[0.74668664 0.         0.         0.85889384 0.        ]
[0. 0. 0. 0. 0.85568623]
[0. 0.81764407 0. 0. 0. ]
[0. 0.93648265 0. 0. 0.75220776]
[0.71149141 0. 0.93260534 0. 0. ]
[0.81701 0.85721634 0. 0. 0. ]
[0. 0. 0. 0. 0. ]
[0.87886815 0.90599216 0. 0. 0. ]
[0.75469648 0.89312007 0. 0. 0. ]
[0.90195641 0. 0.95517067 0.86300827 0. ]]

5. Visualisation des données avec Matplotlib

5.1. Afficher une fonction simple

1
2
3
4
5
import matplotlib.pyplot as plt

# Afficher une ligne
x = np.linspace(0, 10, 100)
plt.plot(x, np.sin(x))

Résultat:

image

5.2. Afficher un nuage de points (scatter plot)

1
2
3
4
5
import matplotlib.pyplot as plt

x = np.random.normal(size=500)
y = np.random.normal(size=500)
plt.scatter(x, y)

Résultat:

image

5.3. Tracer une image

1
2
3
4
5
6
7
8
import matplotlib.pyplot as plt

x = np.linspace(1, 12, 100)
y = x[:, np.newaxis]

im = y * np.sin(x) * np.cos(y)

plt.imshow(im)

Résultat:

image

5.4. Tracer les contours

1
2
3
4
5
6
7
8
import matplotlib.pyplot as plt

x = np.linspace(1, 12, 100)
y = x[:, np.newaxis]

im = y * np.sin(x) * np.cos(y)

plt.contour(im)

Résultat:

image

5.5. Gallerie d’exemples

Des centaines d’exemples sont disponibles sur le site de Matplotlib.
En exécutant la commande suivante dans votre notebook, le code source sera téléchargé. Vous n’aurez plus qu’à le ré-excuter pour qu’un graphique s’affiche.

1
%load http://matplotlib.org/mpl_examples/pylab_examples/ellipse_collection.py

5.6. Graphique 3D

1
2
3
4
5
6
# 3D 
from mpl_toolkits.mplot3d import Axes3D

ax = plt.axes(projection='3d')
xgrid, ygrid = np.meshgrid(x, y.ravel())
ax.plot_surface(xgrid, ygrid, im, cmap=plt.cm.jet, cstride=2, rstride=2, linewidth=0)

Résultat:

image

Debugging Misc

“Dumper” un objet:

1
2
3
4
def dump(obj):
for attr in dir(obj):
if hasattr( obj, attr ):
print( "obj.%s = %s" % (attr, getattr(obj, attr)))

Afficher des couleurs dans le terminal

1
print('\x1b[6;30;42m' + 'Success!' + '\x1b[0m')

image

Voir toutes les couleurs disponibles:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def print_format_table():
"""
prints table of formatted text format options
"""
for style in range(8):
for fg in range(30,38):
s1 = ''
for bg in range(40,48):
format = ';'.join([str(style), str(fg), str(bg)])
s1 += '\x1b[%sm %s \x1b[0m' % (format, format)
print(s1)
print('\n')

print_format_table()

Voici quelques examples:

image