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

Chapitre 4 : Built-in functions

Python contient un grand nombre de
fonctions intégrées très utiles à connaitre.
Cela vous permet de construire des codes
plus rapidement, sans avoir à développer
vos propres fonctions pour les taches les
plus basiques.
Dans cette section, je vous montre les plus
importantes :
- Fonctions de bases : abs(), round(),
max(), min(), len(), sum(), any(),
all()
- Conversions de types de variables: int(), str(), float(), type()
- Conversions de structures de données: list(), tuple()
- Conversions binaires (moins utile en machine Learning): bin(), oct(), hex()
- Fonction input()
- Fonction format(), (f-string)
- Fonction open()

IV.1. Fonctions de bases

Utiles en toute circonstance :
x = -3.14
print(abs(x)) # valeur absolue
print(round(x)) # arrondi
liste = [-2, 3, 1, 0, -4]

print(min(liste)) # minimum
print(max(liste)) # maximum
print(len(liste)) # longueur
print(sum(liste)) # somme des éléments
liste = [False, False, True]

print(any(liste)) # y-a-t'il au moins un élément True ?

print(all(liste)) # est-ce-que tous les éléments sont True ?

IV.2. Fonctions de conversion

Il peut être très utile de convertir une variable d'un type à un autre (par exemple pour faire des calculs).
Pour cela, on dispose des fonctions int(), str() et float().
La fonction type() est très utile pour inspecter les types de nos variables
age = '32'
print(type(age))
age = int(age)
print(type(age))
age + 10

On peut également convertir des listes en Tuples, ou des tableaux Numpy (que l'on verra par la suite) en
liste...

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

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

tuple_1 = (1, 2, 3, 4)
liste_1 = list(tuple_1) # convertir un Tuple en liste
print(type(liste_1))

IV.3. La fonction input()

Cette fonction est très utile pour demander à l'utilisateur du programme d'entrer une valeur dans votre
programme :
age = input('quel age avez-vous ?')
print(type(age)) # age est de type string. il faut penser a le convertir si on désire faire un calcul avec

age = int(age)
print(type(age))

new_age = int(input('quel age avez-vous ?')) + age

print(new_age)

IV.4. La fonction format()

Cette fonction permet d'insérer la valeur d'une variable au sein d'une chaine de caractères (string).Une
méthode plus rapide pour utiliser cette fonction est de faire appel au f-string :
x = 25
ville = 'Paris'
message = 'il fait {} degrés a {}'.format(x, ville)
print(message)

#autre méthode
message = f'il fait {x} degrées a {ville}'
print(message)

Cette fonction est très pratique parce qu‘elle peut par exemple permettre a des développeurs d’accéder à
certaines clefs de leurs dictionnaires contenant les paramètres de leurs réseaux de neurones.
import numpy as np
parametres = {"W1" : np.random.randn(2, 4),
"b1" : np.zeros((2, 1)),
"W2" : np.random.randn(2, 2),
"b2" : np.zeros((2, 1)),}
For i in range(1, 3):
print("couche", i)
print(parametres["W{}".format(i)])
#print(parametres["W"+str(i)])#autre méthode

IV.5. La fonction open()

Cette fonction est l'une des plus utiles de Python. Elle permet d'ouvrir n'importe quel fichier de votre
ordinateur et de l'utiliser dans Python. Différents modes existent :
- le mode 'r' : ouvrir un fichier de votre ordinateur en lecture
- le mode 'w' : ouvrir un fichier de votre ordinateur en écriture
- le mode 'a' : (append) ajouter du contenu dans un fichier existant (en écriture à la fin)
#écriture dans un fichier
f = open('text.txt', 'w') # ouverture d'un objet fichier f
f.write('hello')
f.close() # il faut fermer notre fichier une fois le travail terminé

#lecture d’un fichier

f = open('text.txt', 'r')
print(f.read())
f.close()

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

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

Dans la pratique, on écrit plus souvent with open() as f pour ne pas avoir a fermer le fichier une fois le
travail effectué :
With open('text.txt', 'r') as f:
print(f.read())
Pour écrire plusieurs données dans un fichier avec cette méthode pose des problèmes de même que le fait
d’écrire les entiers. Pour résoudre le problème on peut donc utiliser la fonction format()
With open ("fichier.txt", "w") as f:
foriinrange(1, 13):
f.write("{}^2 = {}\n".format(i, i**2)) #pour rentrer à la ligne après chaque opération on utilise le retour
chariot : \n

Exercice : fichier
Le code ci-dessous permet de créer un fichier qui contient les carrée des nombres ailant de 0 jusqu'a 19.
L'exercice consiste à implémenter un code qui permet de lire ce fichier et d'écrire chaque ligne dans une
liste.
Note_1 : la fonction read().splitlines() sera très utile
Note_2 : Pour un meilleur résultat, essayer d'utiliser une liste compréhension !
# Ce bout de code permet d'écrire le fichier
with open('fichier.txt', 'w') as f:
for i in range(0, 20):
f.write(f'{i}: {i**2}\n')
f.close()

Chapitre 5 : Modules
Python contient un certain nombre de modules (fichier contenant du code) intégrés, qui offrent de
nombreuses fonctions mathématiques, statistiques, aléatoires et os très utiles. Pour importer un module, il
faut procéder comme-ci dessous :
- import module (importe tout le module)
- import module as md (donne un surnom au module)
- from module import fonction (importe une fonction du module)
import math
import statistics
import random
import os
import glob

Vous pouvez également créer vos propres modules et les importer dans d'autres projets. Un module n'est
en fait qu'un simple fichier.py qui contient les fonctions, les classes, bref du code.
import test1 #où test1 est notre fichier python (test1.py) qui contient nos fonction, listes, dictionnaires, ...
res = test1.fibonacci(1000) #o appel la fonction fibonacci contenu dans test1.py
print(res)

Utiliser simplement import charge tout le contenu du module dans le module encours, on peut éviter cet
opération en précisant la fonction, la classe, … qu’on veut importer :
from test1 import fibonacci as fib
res = fib(1000)
print(res)

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

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

On peut accéder à la documentation python pour avoir accès à nombreux outils et modules disponible
pour faire du développement sur python

Dans l’environnement anaconda on a accès à plein de packages et de modules émettant de faire

différentes opérations : du html, de lire des images, …

V.1. Modules math et statistics

Les modules math et statistics sont en apparence très utiles, mais en data science, nous utiliserons leurs
équivalents dans le package (ensemble de module regroupe dans un même répertoire) NUMPY. Il peut
néanmoins être intéressant de voir les fonctions de bases.
print(math.pi)
print(math.cos(2*math.pi))

liste = [1, 4, 6, 2, 5]

print(statistics.mean(liste)) # moyenne de la liste

print(statistics.variance(liste)) # variance de la liste

V.2. Module Random

Le module random est l'un des plus utiles de Python. En data-science, nous utiliserons surtout sont
équivalent NUMPY.
random.seed(0) # fixe le générateur aléatoire pour produire toujours le même résultat
print(random.choice(liste)) # choisit un élément au hasard dans la liste
print(random.random()) # génère un nombre aléatoire entre 0 et 1
print(random.randint(5, 10)) # génère un nombre entier aléatoire entre 5 et 10
print(random.randrange(100)) # retourne un nombre aléatoire compris entre 0 et 100
random.sample(range(100), 10) # retourne une liste de 10 nombres aléatoires entre 0 et 100

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

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

print(random.sample(range(100), random.randrange(10))) # retourne une liste de taille (entre 0 et 10 élément)

aléatoire comprenant des nombres aléatoire compris entre 0 et 100

print('liste de départ', liste)

random.shuffle(liste) #mélange les éléments d'une liste
print('liste mélangée', liste)

V.3. Modules OS et Glob

Les modules OS et GLob sont essentiels pour effectuer des opérations sur votre disque dur, comme ouvrir
un fichier situé dans un certain répertoire de travail.
os.getcwd() # affiche le répertoire de travail actuel
print(glob.glob('*')) # contenu du répertoire de travail actuel
print(os.getcwd()) # affiche le répertoire de travail actuel
print(glob.glob('*')) # affiche le contenu du répertoire de travail actuel
print(glob.glob('*.txt')) # affiche les fichiers du répertoire de travail actuel dont l'extension est txt

Imaginons que nous avons plusieurs fichiers texte (un qui contient des noms de ville, un autre les noms de
pays, un fichier qui contient les fruits et leurs prix et un dernier qui contient des tables de multiplications)
que nous voulons analyser dans notre répertoire de travail courant. Nous pouvons donc utiliser toutes ces
données à la chaine à l’aide de la fonction glob() et de la fonction open()
import glob
filenames = glob.glob('*.txt')
for file in filenames:
with open(file, 'r' ) as f:
print(f.read())

Ici on va afficher le contenu de chaque fichier successivement.

Exercice : fichier et Liste

Enregistrer le contenu de chaque fichier dans une liste qui porte un nom spécifique associé à chaque
fichier. Utiliser les dictionnaires pour traiter cet exercice.

Chapitre 6 : POO
La programmation orientée objet est un paradigme, c'est à dire une façon de procéder pour écrire des
programmes clairs et simples. Le principe est de modéliser les éléments de notre programmes (comme les
tableaux et les listes) comme étant des objets caractérisés par des attributs et capables d'effectuer des
actions. Ces objets sont construits à partir de classes qui contiennent leur plan de fabrication. Dans le
langage Python, presque tout est construit pour être un objet : les listes, les dictionnaires, les tableaux
numpy, etc. Par exemple quand on écrit : list.append(), on utilise en fait la méthode append() sur un objet
liste. La documentation Python, Numpy, Pandas, Matplotlib, Sklearn, est donc en vaste majorité
constituée de classes qu'il est important de savoir déchiffrer pour pouvoir apprendre soi-même de
nouvelles choses grâce aux documentations. Voici donc comment créer simplement et efficacement des
classes :
Class vehicule:
"""
Voici un exemple de classe "vehicule" qui contient le plan de conception
d'objets "véhicules"
"""

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

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

# Une classe commence par une fonction initialisation qui contient les différents attributs
Def __init__(self, couleur='noir', vitesse=0, roues=4):
self.couleur = couleur
self.vitesse = vitesse
self.roues = roues

# voici une méthode "accélérer" qui modifie un attribut de l'objet

Def accelerer(self, vitesse):
self.vitesse += vitesse

# voici une autre méthode

Def stop(self):
self.vitesse = 0

# voici une dernière méthode, très souvent utilisée

Def afficher(self):
print(f'couleur: {self.couleur}\n roues: {self.roues}\n vitesse: {self.vitesse}')

# création d'un objet de la classe voiture

voiture_1 = vehicule(couleur='rouge')
voiture_1.afficher() #utilisation de la méthode affiche pour afficher les propriétés de la voiture

voiture_1.accelerer(100) #utilisation de la méthode accélérer pour modifier la vitesse de la voiture

voiture_1.afficher()

- class est un mot clé, vehicule le nom de la classe. Cette ligne alerte l'interpréteur : je veux créer un
objet Python de type class, une nouvelle classe (et non pas un objet de type vehicule qui, lui, sera
créé plus loin). La classe vehicule hérite de la classe object, c'est à dire que tous les attributs de la
classe object peuvent être utilisés par notre nouvelle classe.
- un docstring (""" ente """) pour expliquer le fonctionnement
- la première méthode est un constructeur (méthode spéciale) : __init__ ses quatre arguments sont :
o self : désigne l'objet non encore instancié, de type vehicule, qui appellera cette méthode.
Autrement dit, self est un vehicule, qui n'existe pas encore. De manière analogue, au moment
de la définition d'une fonction (par exemple def f(x) : return x*x) ;x ne désigne aucune variable,
mais prendra corps seulement lorsque la fonction sera appelée par exemple
a=3; f(a).
o couleur, vitesse et roues sont les attributs de la voiture, (par défaut noir, 0 et 4) Il y a création
de trois et couleur, vitesse et roues, dans self. Ces attributs prendront corps en même temps que
self, lorsqu’un vehicule sera instancié.
- accelerer() est une méthode qui modifie la vitesse. L'argument self prendra la valeur
vehicule v lorsque sera exécutée l'instruction v. accelerer()
- Instanciation. L’instruction : voiture_1 =vehicule (couleur='rouge') déclenche les actions suivantes
: appel à vehicule.__init__( couleur='rouge') , =⇒voiture_1 est instancié. Les attributs
voiture_1.couleur, voiture_1.vitesse et voiture_1.roues deviennent effectif, à l'intérieur de
voiture_1.

Créer des sous-classes : Héritage

Class voiture_electrique(vehicule):
"""
La classe moto hérite des méthodes et des attributs de la classe véhicule
"""

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

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

def __init__(self, couleur='black', vitesse=0, roues=4, autonomie=100):

super().__init__(couleur, vitesse, roues) # super() permet d'utiliser la fonction de la classe "parent"
self.autonomie = autonomie

# Ré-écriture de certaines méthodes

def accelerer(self, vitesse):
super().accelerer(vitesse)
self.autonomie -= 0.1 *self.vitesse

def afficher(self):
super().afficher()
print(f'autonomie: {self.autonomie}')

voiture_2 = voiture_electrique() # création d'un objet de la classe voiture de type voiture électrique
voiture_2.afficher() #utilisation de la méthode affiche pour afficher les propriétés de la voiture électrique

voiture_2.accelerer(10) #utilisation de la méthode accélérer pour modifier la vitesse de la voiture électrique ce

qui va aussi modifier l'autonomie
voiture_2.afficher()

class voiture_electrique(vehicule): signifie que la classe voiture_electrique hérite de la classe vehicule.

Donc voiture_electrique est un objet de vehicule. Grâce à cet héritage, tous les attributs et les méthodes de
la classe vehicule peuvent être utilisés et/ou surchargés par les instances de la classe voiture_electrique.

Chapitre 7 : Numpy : Tableau ndarray

Nous avons suffisamment posé les bases pour passer aux choses sérieuses. Pour ce faire nous
commençons par le package NUMPY.
Il faut rappeler que Numpy est l’un des package les plus important pour faire l’intelligence artificielle, la
data-science, le Deep et le machine Learning, Au cœur du package Numpy on trouve un objet
extrêmement puissant : le tableau à N dimensions (Tableau ndarray)

Un tableau a une dimension ressemble a une liste, mais est beaucoup plus puissant, plus rapide, prend
moins d’espace en mémoire et gère beaucoup plus de méthodes pur faire des calcules scientifiques. Nous
utiliserons principalement les tableaux à
deux dimensions où les lignes peuvent
représenter les exemples du Dataset et
les colonnes les variables.

Si on prend le cas du traitement d’une

image, on peut stocker les pixels de
celle-ci dans un tableau à deux

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

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

dimensions. Dans chaque case on peut stocker la valeur du pixel correspond, sachant que les valeurs
partent de 0 a 255 où 0 représente le noir et 255 le blanc.

L’image suivante peut être représentée sur environs 800 lignes et 1050 colonnes.

Par contre si cette image est prise en couleur on pourra donc la décomposer en 3 couleurs vert, bleu et
rouge, chacune étant sur deux dimensions. On aura donc un tableau sur 3 dimensions (chaque dimension
représentant une couleur). Sur chaque couche on aura une valeur de pixel différente et c’est l’assemblage
des trois couches qui va donner la couleur finale pour chaque pixel.

Pour accéder a la liste complète des méthodes, routines, fonctions, … utilisables dans Numpy :

https://numpy.org/doc/stable/reference/

I.1. Générateurs de tableaux ndarray (les plus utiles) :

- générateur par défaut : ndarray()
- générateur 1D : np.linspace et np.arange()
- générateur ND : np.zeros(), np.ones(),
np.random.randn()
import numpy as np

A = np.array([1, 2, 3]) # générateur par défaut, qui

permet de convertir des listes (ou autres objets) en
tableau ndarray
A = np.zeros((2, 3)) # tableau de 0 aux dimensions 2x3
B = np.ones((2, 3)) # tableau de 1 aux dimensions 2x3
C = np.random.randn(2, 3) # tableau aléatoire
(distribution normale) aux dimensions 2x3

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

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

D = np.random.rand(2, 3) # tableau aléatoire (distribution uniforme)

E = np.random.randint(0, 10, [2, 3]) # tableau d'entiers aléatoires de 0 a 10 et de dimension 2x3

A = np.ones((2, 3), dtype=np.float16) # définit le type et la place a occuper sur la mémoire
D = np.full((2,3), 9) #permet de créer un tableau de 2 dimensions (2 ligne et 3 colonnes) rempli de 9
print(D)

B = np.eye(4, dtype=np.bool) # créer une matrice identité et convertit les éléments en type bool.
A = np.linspace(1,10, 100) # tableau d'entiers en distribution égale de 100 valeurs allant de 1 a 10
B = np.arange(0, 10, 1)# tableau d'entiers de valeurs comprises entre 0 et 10 avec un pas, ici 1

I.2. Attributs importants

- Size : c’est un attribut qui permet de retourner le nombre d'éléments dans le tableau ndarray
(ndarray.size)
- shape
L’un des attributs les plus utiles de ndarray est l’attribut shape
(ndarray.shape) qui permet de connaitre la forme de notre tableau. C'est-à-
dire combien il ya de ligne, de colonne, quelle est la profondeur pour les
tableaux à plus de 2 dimensions, …
Pour un tableau à une dimension, on à un premier attribut ndim
(ndarray.ndim) qui sera égale a un étant donné que le tableau a une
dimension. L’attribut shape de cette dimension sera égale a 2 étant donné qu’il y’a deux éléments dans
cette dimension.
shape renvoie un tuple (pas modifiable), donc pour accéder au nombre de ligne, il
faudra écrire l’index 0 : shape[0] et pour accéder au nombre de colonne, il faudra
écrire l’index 1 : shape[1].

A = np.zeros((2, 3)) # création d'un tableau de shape (2, 3)

print(A.ndim) # le nombre de dimension du tableau A

print(A.size) # le nombre d'éléments dans le tableau A
print(A.shape) # les dimensions du tableau A (sous forme de Tuple)
print(type(A.shape)) # voici la preuve que la shape est un tuple
print(A.shape[0]) # le nombre d'éléments dans la premiere dimension de A

I.3. Méthodes importantes

- reshape() : pour redimensionner un tableau
- ravel() : pour aplatir un tableau (qu'il ne fasse plus qu'une dimension)
- squeeze() : quand une dimension est égale a 1, cette dimension disparait
- concatenate() : assemble 2 tableaux ensemble selon un axes (existe aussi en hstack et vstack)
A = np.zeros((2, 3)) # création d'un tableau de shape (2, 3)
A = A.reshape((3, 2)) # redimensionne le tableau A (3 lignes, 2 colonnes)
A.ravel() # Aplatit le tableau A (une seule dimension)
A = A.reshape((A.shape[0], 1)) # si n a besoin de faire apparaitre la dimension 1 du tableau
A.squeeze() # élimine les dimensions "1" de A.
A = np.zeros((2, 3)) # création d'un tableau de shape (2, 3)
B = np.ones((2, 3)) # création d'un tableau de shape (2, 3)

On assemble deux tableaux de nombre de colonne identique: on superpose les lignes et le nombre de
colonne reste identique

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

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

C =np.concatenate((A, B), axis=0) # axe 0 : équivalent de np.vstack((A, B))

D = np.vstack((A, B))
print("tab1 :", C, "\n","tab2 :", D)

Onassemble deux tableaux de nombre de ligne identique: on superpose les colonnes et le nombre de ligne
reste identique
E = np.concatenate((A, B), axis=1) # axe 1 : équivalent de np.hstack((A, B))
F = np.hstack((A, B))
print("tab3 :", E, "\n","tab4 :", F)

Exercice : fonction initialisation

Créer une fonction initialisation qui prend deux arguments m (nombre de ligne) et n (nombre de colonne)
pour créer une matrice aléatoire de dimension (m, n+1). Où on a une matrice rempli de 1 tout à droite de
la matrice.
def initialisation(m, n):
# m : nombre de lignes
# n : nombre de colonnes
# retourne une matrice aléatoire (m, n+1)
# avec une colonne biais (remplie de "1") tout a droite

return X

I.4. Numpy : Slicing et Indexing

En machine Learning et en data science on travail généralement sur les tableaux a
deux démentions où nous avons un axe 0 qui correspond aux lignes et un axe 1 qui
correspond aux colonnes. Pour éviter de faire les erreurs, il est préférable de se
déplacer sur un axe à la fois.
Le fonctionnement est le même que pour les listes :
import numpy as np

A = np.array([[1, 2, 3], [4, 5, 6]])

print(A)

# Indexing
# Pour accéder a la ligne 0, colonne 1
A[0, 1]
# Pour accéder a tous les éléments de la ligne 0
A[0] #équivalent à A[0, :]
# Pour accéder a tous les éléments de la ligne 1
A[1] #équivalent à A[1, :]

# Pour accéder a tous les éléments de la colonne 0

A[ :,0]
# Pour accéder a tous les éléments de la colonne 1
A[ :,1]

# slicing
# Pour sélectionner les blocs de la ligne (0-1) colonne (0-1)
A[0:2, 0:2]

# Pour modifier les valeurs d'un les blocs de la ligne (0-1) colonne (0-1) sélectionner
A[0:2, 0:2] = 10
print(A)

I.5. Boolean Indexing

import numpy as np

A = np.array([[1, 2, 3], [4, 5, 6]])

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

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

print(A<5) # masque booléen

print(A[A <5]) # sous-ensemble filtré par le masque booléen

A[A<5] = 4# convertit les valeurs sélectionnées en leur attribuant une nouvelle valeur, ici 4
print(A)

A[(A<5) & (A>2)] = 10# convertit les valeurs sélectionnées en leur attribuant une nouvelle valeur, ici 10
print(A)

A[A<5] # retourne le tableau A pour lequel les valeur sont inferieur à 5, changeant ainsi la forme du tableau
print(A)
print(A.shape)

B = np.ramdom.randn(2,3) # matrice de même dimension que A

B[A<5] #B obtient des valeur qui sont obtenue a partir du masque de A
print(B)

Exercices et Solutions
Exercice 1 : matrice
Remplir les 4 blocs du milieu de la matrice suivante par des "1" :
B = np.zeros((4, 4))

Exercice 2 : tableau
Remplir le tableau de "1" (une ligne sur deux, une colonne sur deux)
C = np.zeros((5, 5))

Exercice 3 : slicing
Sur l'image ci dessous, effectuer un slicing pour reduire l’image d’un
quart de chaque coté (ne garder que le centre) et remplacer tous les
pixels > 150 par des pixels = 255
import numpy as np
from scipy import misc# le package qui contient l’image
import matplotlib.pyplot as plt# le package qui permet l’affichage de l’image

face = misc.face() # on charge l’image en couleur (juste pour voir)

plt.imshow(face) #on affiche l’image
plt.show()#on lance la fenêtre qui contient l’image
print(face.shape) #(768, 1024, 3)

face = misc.face(gray=True)# on charge l’image en noir sur blanc (pour avoir 1

dim)
plt.imshow(face, cmap=plt.cm.gray)# on affiche l’image en définissant la couleur
plt.show()# on lance la fenêtre qui contient l’image
print(face.shape) #(768, 1024)

I.6. Numpy : Mathématiques

a.1) 1. Méthodes de bases (les plus utiles) de la classe ndarray
import numpy as np
A = np.array([[1, 2, 3], [4, 5, 6]])

print(A.sum()) # effectue la somme de tous les éléments du tableau

print(A.sum(axis=0)) # effectue la somme des colonnes (somme sur éléments des lignes)
print(A.sum(axis=1)) # effectue la somme des lignes (somme sur les éléments des colonnes)
print(A.cumsum(axis=0)) # effectue la somme cumulée des colonnes (somme sur éléments des lignes)
print(A.prod()) # effectue le produit
print(A.cumprod()) # effectue le produit cumulé

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

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

print(A.min()) # trouve le minimum du tableau

print(A.max()) # trouve le maximum du tableau
print(A.min(axis=0))#trouve le minimum de chaque colonne du tableau
print(A.min(axis=1))#trouve le minimum de chaque ligne du tableau
print(A.argmin(axis=0))#trouve la position du minimum de chaque colonne
du tableau

Une méthode très importante : la méthode argsort()

A = np.random.randint(0, 10, [5, 5]) # tableau aléatoire
print(A)
print(A.argsort()) # retourne les index pour trier chaque ligne du tableau
print(A[:,0].argsort()) # retourne les index pour trier la colonne 0 de A
A = A[A[:,0].argsort(), :] # trie les colonnes du tableau selon la colonne 0.
print(A)

Pour faire la trigonométrie et autres

print(np.exp(A)) # calcul l’exponentiel de chaque nombre de a ; on peut faire de même avec toutes les fonction cos,
sin, sinh, log, …

a.2) Numpy Statistics

Toutes les routines y relatives sont documentées à l’adresse :
https://numpy.org/doc/stable/reference/routines.statistics.html
print(A.mean()) # calcule la moyenne, on peut aussi calculer selon les axes
print(A.std()) # calcule l'écart type,
print(A.var()) # calcule la variance

Corrélation de Pearson :
B = np.random.randn(3, 3) # nombres aléatoires 3x3

# retourne la matrice de corrélationde B ; corrcoef : corrélation coefficient

print(np.corrcoef(B))

# retourne la matrice de corrélation entre les lignes 0 et 1 de B

print(np.corrcoef(B[:,0], B[:, 1]))

#np.unique() :
np.random.seed(0)
A = np.random.randint(0, 10, [5,5])
print(A)

Il est parfois utile de connaitre le nombre de fois qu’un élément apparait dans un tableau. On peut donc
utiliser la fonction np.unique pour compter ces éléments. La fonction nous retourne deux variables, une
qui contient les valeurs comprise dans le tableau et une qui correspond au nombre de fois que chacune des
valeurs apparait. Il est possible de classer ses éléments en fonction de leurs nombre d’appariations dans le
tableau avec la fonction argsort()
print(np.unique(A)) #retourne chaque élément qui apparait dans la matrice

values, counts = np.unique(A, return_counts=True)

for i, j inzip(values[counts.argsort()], counts[counts.argsort()]):
print(f'valeur {i} apparait {j}')

Calculs statistiques en présence de données manquantes (NaN : Not a Number)

A = np.random.randn(5, 5)
A[0, 2] = np.nan # insère un NaN (Not a Number) dans la matrice A
print('Nombre de NaN:', np.isnan(A).sum()) # calcule e nombre de NaN dans A
print('ratio NaN/zise:', (np.isnan(A).sum()/A.size)) # calcule la proportion de NaN dans A
print('moyenne sans NaN:', np.nanmean(A)) # calcule la moyenne de A en ignorant les NaN

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

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

print('variance sans NaN:', np.nanvar(A)) # calcule la variance de A en ignorant les NaN

print('ecart type sans NaN:', np.stdmean(A)) # calcule l’écart type de A en ignorant les NaN
print('Nombre de NaN:', np.isnan(A).sum()) # calcule e nombre de NaN dans A
A[np.isnan(A)] = 0 # remplace les NaN dans A par de 0
print(A)

a.3) Algèbre Linéaire

A = np.ones((2,3))
B = np.ones((3,3))

print(A.T) # transposé de la matrice A (c'est un attribut de ndarray)

print(A.dot(B)) # produit matriciel A.B

A = np.random.randint(0, 10, [3, 3])

print('det=', np.linalg.det(A)) # calcule le déterminant de A

print('inv A:\n', np.linalg.inv(A)) # calcul l'inverse de A
print('inv A:\n', np.linalg.pinv(A)) # calcul la pseudo l'inverse de A

val, vec = np.linalg.eig(A)

print('valeur propre:\n', val) # valeur propre
print('vecteur propre:\n', vec) # vecteur propre

Exercice
Exercice 1 : Standardisation
Standardisez la matrice suivante, c'est à dire effectuez le calcul suivant :
np.random.seed(0)
A = np.random.randint(0, 100, [10, 5])
print(A)

Chaque colonne doit avoir une moyenne = 0 et un écart type = 1

# SOLUTION
D = (A - A.mean(axis=0)) / A.std(axis=0)
print(D)
print(D.mean(axis=0)) # les moyennes sont toutes = 0
print(D.std(axis=0)) # les std sont tous = 1

Exercice 2 : image
Soit la solution de l’exercice 3 précédent (sur l’image), calculer le nombre de fois qu’apparait chaque
pixel. On veillera a mettre le résultat sous la forme :
La valeur 3 apparait 17 fois
La valeur 6 apparait 17 fois
La valeur 5 apparait 18 fois
La valeur 0 apparait 20 fois
import numpy as np
from scipy import misc # le package qui contient l’image
import matplotlib.pyplot as plt # le package qui permet l’affichage de l’image

face = misc.face() # on charge l’image en couleur (juste pour voir)

plt.imshow(face) #on affiche l’image
plt.show()#on lance la fenêtre qui contient l’image
print(face.shape) #(768, 1024, 3)

face = misc.face(gray=True) # on charge l’image en noir sur blanc (pour avoir 1 dim)
plt.imshow(face, cmap=plt.cm.gray) # on affiche l’image en définissant la couleur
plt.show()# on lance la fenêtre qui contient l’image
print(face.shape) #(768, 1024)

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

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

I.7. Numpy et Broadcasting

Le broadcasting est une technique assez puissante mais qui peut s’avérer dangereuse. En effet, cette
technique nous permet de faire les calcules entre deux tableaux de
manières très simple et très rapide sur Numpy.
En C, C++ et d’autres langages, pour addition les données de deux
tableaux, il faut procéder a l’addition des valeurs indice par indice dans
des boucles. Avec Numpy, si nous avons deux tableaux A et B, il suffit d’écrire
par exemple C = A + B. en fait toutes ces boucles ont déjà été implémentées dans
le module.
import numpy as np
np.random.seed(0)
A = (np.random.randint(0, 10, [2,3]))
print(A)
B = np.ones((2, 3))
print(A)
print("Somme : ", A + B)

Lorsque nous faisons des opérations sur des tableaux de dimensions différentes en principe nous obtenons
une erreur.
import numpy as np
np.random.seed(0)
A = (np.random.randint(0, 10, [2,3]))
print(A)
B = np.ones((2, 2))
print(A)
print("Somme : ", A + B) #erreur

Mais avec Numpy, pas forcement. Si le tableau peut être étendu, alors l’opération peut être effectuée.Pour
cela, l’un des tableaux va être étendu: c’est ce qu’on appel le BROADCASTING. Par exemple si on fait
le tableau A + 2, où 2 est un scalaire et donc un tableau de dimension (1, 1) ; ce tableau sera étendu pour
s’additionner au reste des indices du tableau A.
import numpy as np
A = np.ones((2, 3))
B = 3
print(A+B) # résultat

De même si nous avons un vecteur B on eut faire l’opération. Ce tableau sera étendu pour s’additionner
au reste des indices du tableau A.
B = np.ones((2,1)) #B est de dimensions 2 lignes 1 colonne
print(B)

print("Somme : ", A + B) # résultat

Il y’a toutefois des règles à respecter : chacune des dimensions dans A et B doivent être égale ou égales à
1. Si les deux tableaux sont différents, l’une des dimensions doit être égale dans les deux tableaux et
l’autre égale à 1 dans l’un des tableaux. Dans le cas des matrices lignes et des matrices colonnes, les deux
tableaux font s’étendre mutuellement pour s’additionner.

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

 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