Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

A = np.ones((2, 3))
print(A)
B = np.ones((2, 1)) # B a une colonne, elle sera étendu sur les trois colonnes de A
print(B)
print("Somme : ", A + B) # résultat

A = np.ones((2, 3))
print(A)
B = np.ones((1, 3)) # B a trois colonnes et une ligne, elle sera étendu sur les deux lignes de A
print(B)
print("Somme : ", A + B) # résultat

A = np.ones((4, 1)) # Aa une colonne et quatre lignes, elle sera étendu

print(A)
B = np.ones((1, 3)) # B a trois colonnes et une ligne, elle sera étendu
print(B)
print("Somme : ", A + B) # résultat

A = np.ones((2, 3))
print(A)
B = np.ones((2, 2)) # B a deux colonnes et deux ligne, elle ne sera pas étendu
print(B)
print("Somme : ", A + B) # Erreur

Note : évitez toutefois de travailler en broadcasting avec des dimensions incomplètes du genre (3,) pour
éviter d’avoir des résultatsinattendus. En fait (3,) donnerait 3 lignes et une colonne, mais en broadcasting
ce résultat ne sera pas obtenu. Il faut donc pensez à bien redimensionner nos matrice du genre (3,1) en
utilisant la méthode reshape.

Chapitre 8 : Matplotlib : Graphiques de Base

Matplotlib est un outil très puissant qui va vous permettre de tracer très facilement tous les graphiques
que vous pourriez imaginer, des graphiques qui montrent réellement le comportement de vos systèmes.

33 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

 Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

De manière générale, le but d’un graphique est de :

- Voir, plutôt qu’imaginer l’abstrait,
- Mieux comprendre le problème,
- Mieux expliquer un phénomène,
- Nous aider a mieux comprendre et interpréter les chiffes dans la résolution de nos problèmes.
Matpltlib est facile si vous faite simple : évitez
de mettre trop de détails dans les courbes. Mais
surtout évitez de mélanger les méthodes OOP
(orientée objet) et pyplot (plt.plot).
Les deux méthodes donnent exactement le même
résultat donc il est préférable de travailler avec
l’une des deux.

II.1) Pyplot
Nous allons utiliser la méthode plot qui vient du module pyplot de
matplotlib, et qui est plus simple à utiliser.
import numpy as np
import matplotlib.pyplot as plt

Pour utiliser cette méthode, il faut définir les données à afficher sur l’axe
X, puis celles a afficher sur l’axe Y, à la condition que X et Y soient de
dimensions égales. Plt.show() permet d’afficher le graphique.

a.1) Graphiques simples

import numpy as np
import matplotlib.pyplot as plt

X = np.linspace(0, 2, 10)
y = X**2

plt.plot(X, y)
plt.show()

34 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

 Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

La fonction scatter permet de tracer un nuage de points.

plt.scatter(X, y)
plt.show()

a.2) Styles Graphiques

Il existe beaucoup de styles à ajouter aux graphiques. Voici les plus
importants à retenir :
- c : couleur de la ligne
- lw : épaisseur de la ligne (pour les graphiques plots)
- ls : style de la ligne (pour les graphiques plots)
- size : taille du point (pour les graphiques scatter)
- marker: style de points (pour les graphiques scatter)
- alpha : transparence du graphique
plt.plot(X, y, c='red', lw=4, ls='--', alpha=0.8)
plt.show()

a.3) Cycle de vie d'une figure

Pour créer des figures proprement, on doit suivre le cycle de vie
suivant :
- plt.figure(figsize = (dim x, dim y)) : permet de créer la feuille
de travail sur laquelle la fenêtre va s’afficher. Nous devons
préciser les dimensions de la feuille en inch.
- plt.plot() : permet de tracer les courbes dans la feuille (figure) que nous avons créé. La légende du
graphe est définie dans cette fonction.
- Extras (titre, axes, légendes) : pour donner plus de renseignement sur le graphe.
- plt.show() : permet d’afficher le graphique
- plt.savefig(‘nom_im.extention’) : permet de sauvegarder notre figure dans le répertoire de
travail de notre disque dur sous forme d’image.
X = np.linspace(0, 2, 10)

plt.figure() # Création d'une figure

plt.plot(X, X**2, label='quadratique') # première courbe
plt.plot(X, X**3, label='cubique') # deuxième courbe
# Extra information
plt.title('figure 1') # titre
plt.xlabel('axe x') # axes
plt.ylabel('axe y') # axes
plt.legend() # legend

plt.savefig('figure.png') # sauvegarde la figure dans le repertoire de

travail
plt.show() # affiche la figure

a.4) Subplots
Les subplots sont un autre élémentà ajouter pour créer plusieurs graphiques sur une même figure.

35 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

 Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

Avec l’utilisation des fonctions subplot(), le cycle de vie des

fonctions est légèrement modifié. Il faut donc définir les
informations de chaque graphe dans sa section.
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2, 10)
y = x**2

plt.figure() # Création d'une figure

plt.subplot(2, 1, 1)
plt.plot(x, y, c='red', label='graphe 1')
plt.title('Graphique 1')
plt.legend()
plt.subplot(2, 1, 2)
plt.plot(x, np.sin(x), c='blue', label='sinus x')
plt.plot(x, np.cos(x), c='green', label='cosinus x')
plt.title('Graphique 2')
plt.legend()
plt.show() # affiche la figure

a.5) Méthode orientée objet

Nous avons dit au début qu’il existe deux méthodes pour tracer les graphes sur matplotlib. Apres le
module pyblot, ici nous verrons quelques éléments d’orientées objet pour tracer les graphes. Mais
personnellement, je vous conseil de mémoriser la première méthode basée sur pyplot, parce qu’au final
les deux presque le même travail. Toutefois la méthode OOP est légèrement plus poussée mais pourra
également vous apporter beaucoup d’ennuie. Et n’oubliez pas de ne jamais mélanger les deux méthodes.
Ici on commence par créer deux objets : une figure et un axe qui pourrons utiliser des méthodes. Pour ce
faire on utilise la fonction subplots() ici avec s contrairement à subplot() vu précédemment.
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2, 10)
y = x**2
fig, ax = plt.subplots()
ax.plot(x,y)
plt.show()

La technique orientée objet est plus intéressant que la première méthode

parce qu’il y’a plus de possibilité. On peut par exemple créer des
graphiques qui partagent la même abscisse (avec l’attribut sharex = True)
ou la même ordonnée (avec l’attribut sharey = True). Mais dans ce cas, il

36 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

 Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

faut afficher chaque graphe à une position. Etant donnée que fig est un
objet, et ax un tableau ndarray qui contient des objets, il faut préciser la
position de chaque objet. Et dans la fonction subplots(), il faut définir le
nombre d’objets.
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2, 10)
y = x**2

fig, ax = plt.subplots(2, 1, sharex=True) # partage le même axe pour les subplots

ax[0].plot(x, y, c='red')#on trace le premier graphe
ax[1].plot(x, np.sin(x), c='green')#on trace le deuxième graphe
plt.show()

Exercice : fonction graphique

Créez une fonction "graphique" qui permet de tracer sur une seule et même
figure une série de graphiques issue d'un dictionnaire contenant plusieurs
Dataset s. Nous utiliserons le Dataset suivant :
defgraphique(Dataset ):
# Votre code ici...
return

# Voici le Dataset utilisé

Dataset = {f"experience{i}": np.random.randn(100) for i inrange(4)}

print(Dataset )

II.2) Matplotlib Top Graphiques

Il s’agit principalement ici de présenter le top cinq des graphiques les plus utiles pour faire du machine
Learning.

a.1) Graphique de Classification avec Scatter()

En machine Learning, la grande majorité des problèmes que vous allez rencontrer sont de problèmes de
classification.

37 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

 Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

Par exemple, on peut vouloir classer un mail : il sera dans notre boite de réception (non spam) ou dans la
boite de Spam en fonction de plusieurs attributs
que le mail aura : le nombre de fautes
d’orthographe, le nombre de lien internet
contenue dans le mail. Pour résoudre ce

problème, nous avons deux classes (Spam et Non-

Spam). Pour représenter un tel Dataset de
classification, le graphique plt.scatter() est un des
meilleurs choix que vous pourriez faire.
Dans ce cours, nous allons voir comment faire un tel graphique avec Dataset assez connu : celui de la
fleur de d’Iris. Ce Dataset contient 150 exemples de fleurs d’iris repartis en trois classes et on dispose de
quatre variables pour prédire de quelle classe il s’agit. Les variables sont : la longueur et la largeur du
pétale de la fleur et la longueur et la largeur du sépale de la fleur.
Pour réussir cette analyse, nous avons utilisé le Dataset de la fleur d’iris disponible dans le package
sklearn (qui contient un ensemble de datatsets que nous verrons plus tard).
import numpy as np
import matplotlib.pyplot as plt
from sklearn.Dataset s import load_iris#on importe le Dataset de la fleur d’iris à contenu dans Sklearn

iris = load_iris()# on charge le data dans un tableau nommé iris

x = iris.data#le Dataset contient les données (nos variables : longueurs et largeurs du pétale et du sépale)
y = iris.target#le Dataset contient également nos classes : 0, 1 et 2.

Nous enregistrons ses tableaux dans les variables x et y qui vont nous servir pour créer nos graphiques.
On peut parcourir les tableaux pour savoir ce qu’ils contiennent :
print(f'x contient {x.shape[0]} exemples et {x.shape[1]} variables') # x contient 150 exemples et 4 variables
print(f'il y a {np.unique(y).size} classes') # il y a 3 classes

Ou simplement afficher les tableaux et voir que x a effectivement 4 colonnes et 150 lignes et que y
contient bien 150 exemples répartis en trois classes (0, 1 et 2)
print(x)
print(y)

Un des meilleurs choix pour visualiser un tel Dataset, comme nous avons dis c’est d’utiliser plt.sacatter.
On pourrait dans un premier temps se contenter de fairepasser en abscisses de des 4 variables que nous
avons :
plt.scatter(x[:, 0], x[:, 1]) #on prend toutes les lignes de la colonne 0, on fait de même pour la colonne 1
plt.show()

38 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

 Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

On obtient un nuage de point. On peur par la suite s’amuser à colorier chaque point du nuage de point en
fonction de sa classe (on sait que y contient nos classes) :
plt.scatter(x[:, 0], x[:, 1], c=y, ) #on prend toutes les lignes de la colonne 0, on fait de même pour la colonne 1
plt.xlabel('longueur sépale')
plt.ylabel('largeur sépale')
plt.show()

On aura donc notre nuage contenant trois couleurs de point où les points sont repartis par classes en
fonction de deux variables x[0] et x[1] qui représentent respectivement la longueur du sépale et la largeur
du sépale. Le paramètre alpha permet de contrôler la transparence de nos oints et s permet de contrôler la
taille.
plt.scatter(x[:, 0], x[:, 1], c=y, alpha= 0.5, s= 100) #on modifie la taille et la transparence
plt.xlabel('longueur sépale')
plt.ylabel('largeur sépale')
plt.show()

C’est encore plus intéressant parce qu’on peut contrôler la taille de nos point en fonction de nos variable
(col 0 : longueur sépale, col 1 : largeur sépale, colonne 2 : longueur pétale, col 3 : largeur pétale). Si on
prend donc la troisième variable, tous les points n’auront pas la même taille. Plus le point sera gros plus la
longueur de son pétale sera grande et inversement.
plt.scatter(x[:, 0], x[:, 1], c=y, alpha= 0.5, s= x[:, 2]*100) #on modifie la taille en fonction de la longueur
plt.xlabel('longueur sépale')
plt.ylabel('largeur sépale')
plt.show()

Une des limites de plt.scatter est que nous ne pouvons représenter

que deux des 4 variables dont nous disposons. Mais ce problème
peut être résolu en utilisant les notions déjà vues.
n = x.shape[1]
plt.figure(figsize=(12, 8))
for i inrange(n):
plt.subplot(n//2, n//2, i+1)
plt.scatter(x[:, 0], x[:, i], c=y)
plt.xlabel('0')
plt.ylabel(i)
plt.colorbar(ticks=list(np.unique(y)))
plt.show()

a.2) Graphiques 3D
Le graphique 3D nous vient de mpl_toolkits qui est l’un des sous package de maplotlib. Avec ce package
on peut faire des graphique 3D qui peuvent se montrer très utile quand on désire visualiser plusieurs
variablesd’un seul coup sur un seul et même graphique. Pour y parvenir, il faut commercer par charger les
graphiques 3D que nous avons dans mpl_toolkits ensuite il faut créer un objet axe avec la foncions axes
que nous avons dans plt avec le paramètre projection = ‘3D’. Vous aurez compris que la création de
graphique 3D avec maplotlib utilise la POO (pas vraiment compliqué). Pour afficher nos variables, on
appel la méthode scatter sur l’objet axe que nous avons crée et lui passant en paramètres les valeurs des
variables à afficher. On peut colorier par classes avec l’attribut c=y vu précédemment.
import matplotlib.pyplot as plt
from sklearn.Dataset s importload_iris

39 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

 Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

from mpl_toolkits.mplot3d importAxes3D# on charge des graphiques 3D que nous avons dans mpl_toolkits

iris = load_iris() # on charge le data dans un tableau nommé iris

x = iris.data #le Dataset contient les données (nos variables : longueurs et largeurs du pétale et du sépale)
y = iris.target #le Dataset contient également nos classes : 0, 1 et 2.

ax = plt.axes(projection='3d')# création d’un objet ax avec la foncions axes que nous avons dans plt
ax.scatter(x[:, 0], x[:, 1], x[:,2], c=y)#appel de scatter sur ax avec en paramètres les valeurs des variables à afficher
plt.show()

Vous pouvez désormais vois le graphe en 3D, tourner dans tous les sens,
zoomer, … pour afficher le rendu sur Jupiter, il faut commencer le code
par %matplotlib.
Vous pourrez désormais visualiser des surfaces et d’autres fonctions
mathématiques que vous aurez modélisées.

Prenons pour l’exemple une fonction f(x, y) = np.sin(x) + np.cos(x+y) que nous créons avec la fonction
lambda qui est un générateur de fonction anonyme. Pour afficher une fonction pareille en 3D, il faut tout
d’aborddéfinirdeux vecteurs numpy X et Y (même nombre de valeurs) et ensuite générer une grille avec
la fonction meshgrid() de numpy. La fonction meshgrid()
nous permet de créer une grille a partir de deux axes X et Y.

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d importAxes3D

f = lambdax, y: np.sin(x) + np.cos(x+y)# on définie la fonction f

X = np.linspace(0, 5, 50) # on définie la plage de valeurs du vecteur X comprenant

50 valeurs
Y = np.linspace(0, 5, 50)# on définie la plage de valeurs du vecteur y comprenant
50 valeurs
X, Y = np.meshgrid(X, Y)# on génère la grille en fonction de X et Y
Z = f(X, Y)# on définie une variable Z qui est égale a notre fonction

ax = plt.axes(projection='3d')# création d’un objet ax avec la foncions axes que

nous avons dans plt
ax.plot_surface(X, Y, Z, cmap='plasma')#appel de scatter sur ax avec en paramètres les
valeurs des variables à afficher
plt.show()

a.3) Histogrammes
C’est un graphique très important, parce qu’il permet de voir la distribution des données sur lesquelles
nous travaillons. Il est parfois important de connaitre si la distribution de ns données est normale,
symétrique, asymétrique ou de visualiser ou se situe la moyenne, le maximum, le minimum, …
import numpy as np
import matplotlib.pyplot as plt

x = np.random.randn(1000)

plt.figure(figsize=(12, 3))
plt.subplot(121)
plt.hist(x, bins=10)
plt.title('bins=10')
plt.subplot(122)

40 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

 Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

plt.hist(x, bins=50)
plt.title('bins= 50')
plt.show()

Si nous reprenons notre datatset avec les fleurs d’iris, on peut décider de visualiser comment sont
distribuées nos quatre variables. On peut donc faire passer l’une de nos variables dans la fonction hist() de
matplotlib et voir comment les données sont distribuées.
from sklearn.Dataset s importload_iris
import matplotlib.pyplot as plt

iris = load_iris()
x = iris.data
plt.hist(x[:,0])# données de la variable 0
plt.xlabel('longueur sépal')
plt.show()

On peut ainsi voir la distribution des données de la variable 0 des toutes nos Feurs d’iris : sur l’axe des
abscisses nous avons toutes les valeurs que peuvent prendre la longueur d’un sépale, ainsi le sépale le
plus petit aura avirons 4,5cm et le plus long un peut moins de 8 cm. Sur l’axe des ordonnées nous avons
le nombre d’apparition de chaque catégorie ; on peut voir qu’on aura un peu plus de 25 fois les sépales de
5,5 cm de long. L’attribut bins dans la fonction hist() permet de définir le nombre de section qu’on
souhaite avoir. Ici nous avons 10 sections par défaut, mais nous pouvons décider d’avoir plus : 20, 30 …
On peut également tracer la distribution de plusieurs variables sur un même histogramme :
from sklearn.Dataset s importload_iris
import matplotlib.pyplot as plt

iris = load_iris()
x = iris.data
plt.hist(x[:,0], bins=20)# données de la variable 0
plt.hist(x[:,1], bins=20)# données de la variable 1
plt.xlabel('longueur sépal')
plt.ylabel('Nbre Apparition')
plt.show()

on peut également tracer des histogrammes en de 2D avec la méthode hist2d() pour visualiser la
distribution des données lorsqu’elles suivent deux variables. On
peut y ajouter une colorbar qui permet de voir la fréquence des
apparitions.
from sklearn.Dataset s importload_iris
import matplotlib.pyplot as plt

iris = load_iris()
x = iris.data
plt.hist2d(x[:,0], x[:,1], cmap='Blues')
plt.xlabel('longueur sépal')
plt.ylabel('largeur sépal')
plt.colorbar() #legende : a quoi correspond chacune des couleurs
plt.show()

Enfin, une autre fonction très utile des histogrammes c’est l’analyse des images. Pour faire l’analyse
d’une image en une couleur (noir/blanc par exemple), il faut définir bins = 255. Nous avons vu
précédemment qu’une image comportait 255 valeurs de pixel dont les couleurs allaient de 0 pour le foncé
(noir dans le cas d’une image N/B) à 255 pour le claire (blanc).
import matplotlib.pyplot as plt

41 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

 Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

from scipy import misc#on imorte l’image depuis scipy

# histogramme d'une image

face = misc.face(gray=True) # on enregistre dans l’image dans un tableau numpy appelé face

plt.figure(figsize=(12, 4))
plt.subplot(121)
plt.imshow(face, cmap='gray') #on affiche l’image en N/B
plt.subplot(122)
plt.hist(face.ravel(), bins=255) #on affiche l’histogramme de l’image, ravel permet d’aplatir l’image sur 1 dim
plt.xlabel('Valeur de Pixels')
plt.ylabel('Apparition')
plt.show()

a.4) Graphiques ContourPlot()

Les graphiques contoursplot sont très utiles pour visualiser les modèles qui occupent trois dimensions en
vue de dessus. C’est le cas avec les problèmes d’optimisation ou il est parfois question de trouver le
minimum d’une fonction cout ou de maximiser les revenus. Ce type de graphique joue un rôle majeur
dans la compréhension des problèmes d’optimisation sur lesquels nous travaillons.
Pour exprimer, nous pouvons reprendre la fonction f(x, y) = np.sin(x) + np.cos(x+y) que nous avons
modélisée précédemment et visualiser en 3D. Essayons de la visualiser maintenant en vue de dessus.
import matplotlib.pyplot as plt
import numpy as np

f = lambdax, y: np.sin(x) + np.cos(x+y)

X = np.linspace(0, 5, 50) # on définie la plage de valeurs du vecteur X
comprenant 50 valeurs
Y = np.linspace(0, 5, 50) # on définie la plage de valeurs du vecteur y
comprenant 50 valeurs
X, Y = np.meshgrid(X, Y) # on génère la grille en fonction de X et Y
Z = f(X, Y) # on définie une variable Z qui est égale a notre fonction
plt.contour(X, Y, Z) #appel de contour plot pour visualiser la fonction en vue de
dessus
plt.show()

On obtient ainsi une vue du dessus 3D de notre fonction. On peut rendre ce graphique un peut plus lisible
en augmentant le nombre de niveau (20 par exemple) pour augmenter la précision d’affichage et en jouant
sur les couleurs.
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d importAxes3D

f = lambdax, y: np.sin(x) + np.cos(x+y)

X = np.linspace(0, 5, 50)
Y = np.linspace(0, 5, 50)
X, Y = np.meshgrid(X, Y)
Z = f(X, Y)
plt.contour(X, Y, Z, 20, colors='black') #précision et couleur

42 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

 Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

plt.show()

Avec la couleur noir on obtient ce graphe en noir sur blanc ou tout ce qui est
positif est en trait continu et tout ce qui est négatif est en traits interrompus.
Que nous soyons en mathématique, en économie, en ingénierie ou que nous
ayons des fonctions plus complexeà optimiser les contourplot sont très utiles
pour nous aider à y voir plus claire. On peut également utiliser l’attribua
cmap qui permet de créer une color map.
#contour plot 2
f = lambdax, y: np.sin(x) + np.cos(x+y)

X = np.linspace(0, 5, 50)
Y = np.linspace(0, 5, 50)
X, Y = np.meshgrid(X, Y)
Z = f(X, Y)
plt.contour(X, Y, Z, 20, cmap='RdGy') #précision et relief de couleurs
plt.show()

Ainsi on pourra atteindre le maximum de notre fonction si on tend vers le petit cercle noir et le minimum
si on tend vers le petit cercle rouge (on peut utiliser colors='black' pour mieux visualiser).
Nous pouvons égaiement utiliser une autres fonction : contourf pour jouer sur les nuances de couleurs.
Ainsi on peut ajouter une légende (colorbar) qui permet d’avoir les valeurs qui maximisent et minimisent
nos fonctions.
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d importAxes3D

f = lambdax, y: np.sin(x) + np.cos(x+y) * np.cos(x) #fonction un peu plus

complexe

X = np.linspace(0, 5, 50)
Y = np.linspace(0, 5, 50)
X, Y = np.meshgrid(X, Y)
Z = f(X, Y)
plt.contourf(X, Y, Z, 20, cmap='RdGy') #utilisation de contourf et de la
colorbar
plt.colorbar()
plt.show()

On peut donc lire les valeurs des gradients sur la légende de notre contour plot. On peut également
superposer les deux styles de contour plots.
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d importAxes3D

f = lambdax, y: np.sin(x) + np.cos(x+y) * np.cos(x) #fonction un peu plus complexe

X = np.linspace(0, 5, 50)
Y = np.linspace(0, 5, 50)
X, Y = np.meshgrid(X, Y)
Z = f(X, Y)
plt.contour(X, Y, Z, 20, colors='black') #precision et couleur
plt.contourf(X, Y, Z, 20, cmap='RdGy') #utilisation de contourf et de la colorbar
plt.colorbar()
plt.show()

a.5) Imshow()

43 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

 Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

C’est le graphique qui se place a la tête de tous les graphiques

vuent jusqu’ici parce qu’il permet de faire de choses
absolument fascinante. En premier lieu, il permet de visualiser
les images comme celle que nous avons visualisée
précédemment.
import matplotlib.pyplot as plt
from scipy import misc #on imorte l’image depuis scipy

face = misc.face() # on enregistre dans l’image dans un tableau numpy

appelé face
plt.imshow(face) #on affiche l’image
plt.show()

Mais son utilité va beaucoup plus loin. Si on se souvient bien, notre image nommée face est un tableau
numpy qui contient les différents pixels de notre image. Donc imshow permet d’afficher n’importe quel
tableau numpy. C’est donc là tout l’intérêt d’imshow : pouvoir afficher n’importe quelle matrice sur un
graphique. Ainsi va pouvoir tracer des matrices de corrélation, analyser les problèmes d’optimisation en
mettant tous les schémas possible (par exemple de tracé de labyrinthe) dans une matrice, visualiser un
maque avant de l’utiliser dans le boolean indexing, bref, le nombre de possibilité est énorme.

Affichons un graphe de distribution normal :

import matplotlib.pyplot as plt
import numpy as np

plt.figure(figsize=(12, 3))

# Simple graphique imshow()

X = np.random.randn(50, 50)
plt.subplot(131)
plt.imshow(X)
plt.title('random normal')
plt.show()

Reprenons notre Dataset des fleurs d’iris qui contient 4 variables de 150
exemples chacune repartis en 3 classes. On fait passer à l’intérieur de imshow la fonction corrcoef qui
retourne un matrice de corrélation pour la matrice X. à l’intérieur de fonction corrcoef on fait passé la
transposé (T) de X parce que ce qui nous intéresse c’et la corrélation entre les colonnes et non les lignes.
# Matrice de corrélation des iris
import matplotlib.pyplot as plt
import numpy as np
from sklearn.Dataset s importload_iris

iris = load_iris()
X = iris.data
y = iris.target

plt.imshow(np.corrcoef(X.T), cmap = 'Blues')

plt.title('Iris Corrélation')
plt.colorbar()
plt.show()

Pour finir on peut représenter un problème d’optimisation pour lequel

44 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA

 Python Avancé : pour la Data-science, l’IA, le machine et le Deep Learning

on utilisait contour plot. Ici tout ce qu’on a faire c’est passe le tableau Z qui est un tableau de 100lignes et
100 colonnes
import matplotlib.pyplot as plt
import numpy as np

X = np.linspace(0, 5, 100)
Y = np.linspace(0, 5, 100)
X, Y = np.meshgrid(X, Y)

# Matrice f(X, Y) = sin(X) + cos(Y) * np.cos(x)

f = lambdax, y : np.sin(x) + np.cos(x+y) * np.cos(x)

plt.imshow(f(X, Y))
plt.colorbar()
plt.title('f(x, y) = sin(x) + cos(y) * np.cos(x) ')
plt.show()

Exercice : graphe
Modifier le code de l’exercice précédent afin d’afficher sur une seule et même figure les différentes
variables qu’on a pour notre dateset de la fleur d’iris.
#Solution
import matplotlib.pyplot as plt
from sklearn.Dataset s importload_iris

iris = load_iris()
x = iris.data
n = x.shape[1]
plt.figure(figsize=(12, 8))
…#Code ici
plt.show()

Chapitre 9 : Scipy : Machine Learning

Scipy contient des modules très puissants pour le machine Learning, l'analyse de données, les time séries,
etc. Cette section vous montre quelques unes des fonctions les plus utiles pour faire des calculs
scientifiques. La documentation de scipy disponible sur internet présente une multitude de petits modules
qui permettent de faire des opérations sciatiques bien précises.

III.1. Interpolation
Lors de l’acquisition des signaux, il arrive parfois qu’il manque des
données, dûà la fréquence d’échantillonnage ou aux caractéristiques
descapteursutilisés. Ce qui va nous produire des Dataset s qui
manquent de valeurs. Nous pouvons résoudre le problème en
supprimant les valeurs manquantes mais l’analyse devient donc très
peu satisfaisante. L’idéale est de réaliser une interpolation afin de
compléter les données manquantes.
Interpoler un signal est parfois très utile s'il vous manque des données dans un Dataset. Mais c'est une
technique dangereuse, qui peut parfois transformer la réalité des choses ! Il faut donc déterminer la

45 Par : EBOA Michel A. | Enseignant – Chercheur, LGIA - ENSET DOUALA