Présentation

import numpy as np

Librairie spécialisées dans le calcul numérique :

• Implémentation efficace et très complète des fonctions mathématiques les plus utile.
  • Principales fonctions d’analyse (np.sin, np.log etc.)
  • Manipulation des probabilités (np.random.uniform, np.random.normal …)
• Concept de tableau multidimensionnels (np.array):
  • très utile en machine learning (notion de tenseurs)
  • implémentation extrêmement efficace (vectorisation, vues implicites etc.)

Les tableaux numpy

• Traitement beaucoup plus efficaces que les listes en Python:
• Exemple pour la fonction min vs np.min:

Créer des tableaux

• Depuis une liste Python: np.array([1,2,3])
• Quelques tableaux classiques :
  • np.arange(5): comme range(5)
  • np.arange(1,10): comme range(1,10)
  • np.linspace(1,10,100): renvoie 100 valeurs, espacées entre 0 et 10
  • np.eyes(3): une matrice 3×3 avec des 1 sur la diagonale et 0 ailleurs.
  • np.diag([1,2,3]): une matrice 3×3 avec 1, 2, 3 sur la diagonale et 0 ailleurs.
  • np.ones(3) ([1,1,1]), np.zeros(3), ([0,0,0])
  • np.empty(4): retourne un tableau de taille 4 non initialisé (attention, les valeurs du tableau ne sont pas contrôlées).

Manipuler des tableaux

La plupart des fonctions numpy peuvent être appliquées point à point sur un tableau:

• np.sin(np.arange(5)) applique la fonction sinus sur tous les nombres de 0 à 4.
  • similaire à map(lambda x:sin(x), l) mais plus efficace.
• np.arange(5) * np.arange(5) renvoie [ 0, 1, 4, 9, 16]
• np.arange(4) * np.arange(5) lève ValueError
• Des fonctions d’agrégation: np.sum([1,2,3]) renvoie 6, np.min, np.max etc.

Index et slices

• Comme avec les listes:
  • t[i]: la ième entrée (indexé à partir de 0)
  • t[-1]: la dernière
  • t[i:j]: les entrées i,...,j-1
  • t[i:j:k]: les entrées i,i+k,i+2k..., jusqu’à j-1
  • t[:j]: jusqu’à j-1,
  • t[j:] depuis j
• Indexation avancée : x=np.arange(5)
  • x[arange(3)+1] donne [1,2,3].
  • x[True,False,False,False,True]) est [0,4]
  • x > 3 renvoie [False, False, False, True, True]
  • Que vaut x[x % 2 == 0]? [0,2,4]

Tableaux multidimensionnels

numpy est particulièrement efficace avec des tableaux ayant plus que 1 ou 2 dimensions.

• x.shape renvoie un tuple avec la taille de chaque dimension.
  • par exemple np.diag(4).shape renvoie (4,4)
• Initialisation: np.empty, np.ones, np.zeros prennent une shape en entrée. Par exemple, np.ones((2,2,3)) renvoie:

array([[[1., 1., 1., 1.],
        [1., 1., 1., 1.]],

       [[1., 1., 1., 1.],
        [1., 1., 1., 1.]]])

• Une dimension est souvent appelé axis dans les fonctions.
• Différences avec listes: l = [[0], [1,2]] est une liste
• Mais np.array([[0], [1,2]]) renvoie une erreur car len([0]) != len([1,2])

Fonctions sur plusieurs dimensions

x = np.ones((3,4))
np.sum(x)
np.sum(x,axis=1)
np.sum(x,axis=0)

x = np.ones((3,4,5))
np.sum(x,axis=0)
np.sum(x,axis=(0,2))

Flatten

• x.flatten(): aligne toutes les entrées d’un tableau sur une dimension.
  • ordre par défaut: (0, ..., 0, 0), (0, ..., 0, 1), ..., (0, ..., 1, 0)...
  • pour les matrices, cela veut dire “ligne par ligne”
  • voir documentation pour d’autres ordres

Stack

np.stack((x1,x2...,xn)): prend des tableaux ayant la même shape (d1,...,dp) et crée un tableau t de shape (n,d1,...,dp) tel que t[i] est xi.

y = np.arange(3)
x = np.stack((y+1, y+4))
> array([[1, 2, 3],
>       [4, 5, 6]])

np.stack(x, x+6)
> array([[[ 1,  2,  3],
>         [ 4,  5,  6]],
>        [[ 7,  8,  9],
>         [10, 11, 12]]])

np.stack crée un nouveau tableau :

x=np.arange(5)
y=np.stack((x,x))
y[0][0] = 5

z=[0,1,2,3,4]
w=[z,z]
w[0][0] = 5

Roll

Fait “rouler” le tableau. Retourne une copie :

y
> array([[[ 1,  2,  3],
>        [ 4,  5,  6]],
>
>      [[ 7,  8,  9],
>        [10, 11, 12]]])    

np.roll(y, 1, axis=0)
> array([[[ 7,  8,  9],
>         [10, 11, 12]],
> 
>        [[ 1,  2,  3],
>         [ 4,  5,  6]]]) 

np.roll(y, 1, axis=1)
> array([[[ 4,  5,  6],
>         [ 1,  2,  3]],
> 
>        [[10, 11, 12],
>         [ 7,  8,  9]]])

np.roll(y, 1, axis=2)
> array([[[ 3,  1,  2],
>         [ 6,  4,  5]],
> 
>        [[ 9,  7,  8],
>         [12, 10, 11]]])

Génération aléatoire avec numpy

np.random: contient de nombreuses distributions.

• np.random.uniform(low, high, size) : retourne un tableau de size nombres (floats) uniformément choisis entre low (inclu) et high (exclu)
• np.random.rand_int(low, high, size) : pareil pour les entiers
• np.random.normale(mean, sig, size) : retourne un tableau de size nombres (floats) choisis selon une distribution normale centrée en mean et d’écart type sig.

Générateur pseudo-aléatoire

• Un ordinateur ne peut techniquement pas générer un nombre aléatoire.
• On utilise pour cela des générateurs pseudo-aléatoires, qui ont l’air aléatoire.
• Mathématiquement :
  • on définit la graine (seed) u₀ (souvent choisie à partir de quelque chose d’imprévisible, par exemple, une combinaison de la date, température du CPU etc.)
  • On définit u_n + 1 = f(u_n) avec f qui se comporte presque comme de l’aléatoire.
  • Exemple: u_n + 1 = (1664525u_n + 1013904223) mod  2³²

np.random.seed(42)
print(np.random.rand(3)) 
# toujours 0.3745401188473625

rng = np.random.default_rng(42)
print(rng.random(3))
# toujours 0.3745401188473625

Présentation de la librairie

Librairie pour la visualisation: diagrammes, fonctions etc.

• Très utile en machine learning pour explorer un data set, présenter des résultats
• Fonctionne main dans la main avec numpy
• voir la documentation

Pour la visualisation, on va utiliser uniquement la partie pyplot de matplotlib:

import matlib.pyplot as plt

Tracer une fonction

x=np.linespace(-10,10,20)
plt.plot(x,x*x)
plt.show()

Tracer une courbe paramétrée

t=np.linspace(0,2*np.pi, 100)
plt.plot(np.sin(t),np.cos(t))
plt.show()

t=np.linspace(0,2*np.pi, 100)
plt.plot(np.sin(t),np.cos(t))
plt.axis("equal")
plt.show()

Nuage de points

x=np.random.uniform(-10,10,100)
y=np.random.normal(0,2,100)
plt.scatter(x,y)
plt.show()

Histogrammes

x=["A","B","C","D"]
y=[10, 20, 30, 40]
plt.bar(x,y)
plt.show()

Mise en page

On peut mettre en page les diagrammes :

x = np.linspace(0, 2*np.pi, 200)
y = np.sin(x)

plt.plot(x, y, 
    label='sin(x)',
    color="pink")
    
plt.xlabel('Angle (rad)')
plt.ylabel('Amplitude')
plt.title('Sinus')

plt.legend()
plt.show()

Couleurs

x=["Mozzarella","Gorgonzola","Scarmozza","Ricotta"]
y=[20, 5, 15, 10]
plt.bar(x,y,color=["green","red"])
plt.show()