numpy

Importer numpy

• par convention numpy est utilisé via l'alias np
• cela permet de prefixer les fonctions de la librairie en utilisant np. à la place de numpy.

import numpy as np

Arrays

• les Arrays représentent une collection de valeurs

contrairement aux listes:

• les arrays ont une taille fixe

  • elles peuvent être resize mais cela implique la recopie de l'array

• toutes les valeurs ont le même type

  • typiquement des floats

tout comme les listes:

• les arrays sont mutables
• on peut changer les éléments d'un array

Arrays de numpy

• les array sont fourni par le module numpy
• la fonction array() crée et arrange une liste donnée

import numpy as np

x = np.array([0, 1, 2, 3, 4])
x

array([0, 1, 2, 3, 4])

Affichage

• la fonction print() nous donne un pretty display

print(x)

[0 1 2 3 4]

• l'utilisation du nom de la variable (dans la console uniquement) nous donne un affichage qui nous permet de différencier les array des listes classiques

x

array([0, 1, 2, 3, 4])

Indexe

• on peut utiliser les indexes de la même façon que pour une liste

x[4]

4

x[4] = 2
x

array([0, 1, 2, 3, 2])

Les arrays ne sont pas des listes

• même si ça y ressemble, les array sont une structure de donnée fondamentalement différente:

type(x)

numpy.ndarray

• par exemple, on ne peut pas utiliser des methodes comme append()

x.append(5)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-8-2f1e4fff5cec> in <module>()
----> 1 x.append(5)

AttributeError: 'numpy.ndarray' object has no attribute 'append'

Utilisation de fonctions sur des Arrays

• Si on utilise des opérateurs arithmétiques sur des arrays, on crée un nouvel array auquel, sur chaque élément, a été appliqué l'opérateur

y = x * 2
y

array([0, 2, 4, 6, 4])

• même chose pour les fonctions

x = np.array([-1, 2, 3, -4])
y = abs(x)
y

array([1, 2, 3, 4])

peupler les Array

• pour peupler un array avec un range de valeurs, on utilise la fonction np.arange()

x = np.arange(0,10)
print(x)

[0 1 2 3 4 5 6 7 8 9]

• on peut utiliser une incrémentation float

x = np.arange(0,1,0.1)
print(x)

[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9]

x

array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

Vectorisation de fonctions

• toutes les fonctions ne fonctionnent pas automatiquement avec les arrays
• les fonctions qui fonctionnes avec les arrays sont dites vectorisées
• la majorité des fonctions de numpy sont vectorisées
• on peut définir des fonctions vectorisées nous même (un peu comme la surcharge en C++) grâce a la fonction supérieure numpy.vectorize()

def myfunc(x):
    if x >= 0.5:
        return x
    else:
        return 0.0

fv = np.vectorize(myfunc)

x = np.arange(0, 1, 0.1)
x

array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

fv(x)

array([ 0. ,  0. ,  0. ,  0. ,  0. ,  0.5,  0.6,  0.7,  0.8,  0.9])

Plot de base

• on utilise le module matplotlib pour ploter des graphs
• ce module fait partie de pyplot
• par convention nous importons matplotlib via l'alias plt
• ce module apporte des fonctions très similaires à celles de MATLAB

import matplotlib.pyplot as plt
# uniquement nécéssaire pour Jupyter
%matplotlib inline 

y = x*2 + 5
plt.plot(x, y)

[<matplotlib.lines.Line2D at 0x1bf1870e3c8>]

Plot d'une sin

from numpy import pi, sin

x = np.arange(0, 2*pi, 0.01)
y = sin(x)
plt.plot(x, y)

[<matplotlib.lines.Line2D at 0x1bf187c3080>]

Données multidimensionnelles

• les arrays de numpy peuvent contenir des données multidimensionnelles
• pour créér un array multidimensionnel, nous pouvons passer une liste de listes à la fonction array()

import numpy as np

x = np.array([[1, 2], [3, 4]])
x

array([[1, 2],
       [3, 4]])

Array d'arrays

• un array multidimensionnel est un array d'array
• l'array extérieur contient les lignes
• chaque ligne est un array

x[0]

array([1, 2])

x[1]

array([3, 4])

• l'élément dans la seconde ligne et première colonne est:

x[1][0]

3

Matrices

• nous pouvons transformer un array multidimensionnel en matrice

M = np.matrix(x)
M

matrix([[1, 2],
        [3, 4]])

Plot multidimensionnel avec des matrices

• si nous utilisons plot() pour ploter une matrice, ce dernier utilisera les valeurs de l'axe des y (colones de la matrice).

from numpy import pi, sin, cos

x = np.arange(0, 2*pi, 0.01)
y = sin(x)
ax = plt.plot(x, np.matrix([sin(x), cos(x)]).T)

Performance

• les matrices de numpy sont liées à des fonctions correspondantes écritent en C et FORTRAN
• Ces librairies sont très rapides et peuvent être configurées de façon à ce que les opérations soient faites en parallèle sur plusieurs coeurs.

Opérations sur les matrices

• Une fois que nous avons une matrice nous pouvons lui appliquer des opérations spécifiques à ces dernières
• pour transposer et inverser on utilise respectivement les attributs T et I

import numpy as np

x = np.array([[1, 2], [3, 4]])
M = np.matrix(x)
M

matrix([[1, 2],
        [3, 4]])

Pour effectuer la transposition $M^T$:

M.T

matrix([[1, 3],
        [2, 4]])

Pour effectuer l'inversion $M^{-1}$:

M.I

matrix([[-2. ,  1. ],
        [ 1.5, -0.5]])

Dimensions d'une matrice

• le nombre total d'éléments et les dimensions de la matrice:

M.size

4

M.shape

(2, 2)

len(M.shape)

2

Créer une matrice à partir de strings

• nous pouvons aussi créér des matrices directement à partir de strigs:

I2 = np.matrix('2 0; 0 2')
I2

matrix([[2, 0],
        [0, 2]])

• le point virgule (;) marque le début d'une nouvelle ligne

Multiplication de matrices

• maintenant que nous avons deux matrices, nous pouvons les multiplier:

M * I2

matrix([[2, 4],
        [6, 8]])

Indexes et matrices

• nous pouvons utiliser les indexes et même slicer une matrices en utilisant la même syntaxe que pour les listes

M[:,1]

matrix([[2],
        [4]])

Les slices sont des références

• de la façon suivante, on crée une référence à l'élément slicé et non pas une copie

V = M[:,1] # ne crée pas une copie des éléments mais référence l'objet initial !
V

matrix([[2],
        [4]])

M[0,1] = -2
V

matrix([[-2],
        [ 4]])

Copier des matrices et des vecteurs

• pour copier une matrice ou une slice de ses éléments, on utilise la fonction np.copy()

M = np.matrix('1 2; 3 4')
V = np.copy(M[:,1]) # copie des éléments
V

array([[2],
       [4]])

M[0,1] = -2
V

array([[2],
       [4]])

Somme

• une façon de faire la sommer un vecteur ou une matrice est via une boucle for

vector = np.arange(0.0, 100.0, 10.0)
vector

array([  0.,  10.,  20.,  30.,  40.,  50.,  60.,  70.,  80.,  90.])

result = 0.0
for x in vector:
    result += x

result

450.0

• ce n'est pas une façon éfficace d'effectuer une somme

Somme efficace

• à la place de la boucle for nous pouvons utiliser la fonction sum()
• cette fonction est écrite en C et est beaucoup plus performante

vector = np.array([0, 1, 2, 3, 4])
print(np.sum(vector))

10

Somme des lignes / colones

• quand nous avons affaire à des données multidimensionnelles, la fonction sum() possède un argument axis qui ne permet de spécifier si nous désirons la somme des lignes ou des colonnes

matrix = np.matrix('1 2 3; 4 5 6; 7 8 9')
print(matrix)

[[1 2 3]
 [4 5 6]
 [7 8 9]]

• somme des lignes

np.sum(matrix, axis=0)

matrix([[12, 15, 18]])

• somme des colonnes

np.sum(matrix, axis=1)

matrix([[ 6],
        [15],
        [24]])

Sommes cumulatives

x = np.matrix('1 2 3; 4 5 6; 7 8 9')
print(x)

[[1 2 3]
 [4 5 6]
 [7 8 9]]

y = np.cumsum(x)
print(np.cumsum(x, axis=0))

[[ 1  2  3]
 [ 5  7  9]
 [12 15 18]]

print(np.cumsum(x, axis=1))

[[ 1  3  6]
 [ 4  9 15]
 [ 7 15 24]]

Produit cumulé

• de façon similaire, nous pouvons calculer $\large{y_n = \Pi^{n}_{i-1}{x_i}}$ en utilisant cumprod()

import numpy as np
x = np.array([1, 2, 3, 4, 5])
print(np.cumprod(x))

[  1   2   6  24 120]

• nous pouvons calculer le produit cummulatif entre les lignes et les colonnes en utilisant le paramètre axis.

Génération de nombres pseudo aléatoires

• le sous module numpy.random contient des fonctions pour générer des nombres aléatoires

from numpy.random import normal, uniform, exponential, randint

• supposons que nous avons une variable aléatoire $\large{\epsilon \sim N(0,1)}$
• dans Python nous pouvons utiliser cette distribution de la façon suivante:

epsilon = normal()
print(epsilon)

-1.2582109218484931

• chaque appel de cette variable nous retournera la même valeur

print(epsilon)

-1.2582109218484931

• si nous appellons encore une fois la fonction, celà va nous retourner un nouveau draw de cette distribution:

epsilon = normal()
print(epsilon)

-0.6266440554602674

Nombres pseudo-aléatoires

• en réalité ces nombres ne sont pas des nombres aléatoires
• ils sont basés sur un état initial appelé seed
• si nous connaissons le seed, nous pouvons prédire précisément le reste de la séquence à partir de n'importe quel nombre "aléatoire".
• cela dit, statistiquement parlant ces nombres se comportent comme des nombres aléatoires

Gestion des seed

• dans certains cas nous avons besoin de pouvoir reproduir une séquence de nombres pseudo aléatoires
• nous pouvons spécifier la valeur du seed avant utilisation de ces nombres
• pour se faire on utilise la fonction seed() dans le sous module numpy.random

from numpy.random import seed

seed(5)

normal()

0.44122748688504143

normal()

-0.33087015189408764

seed(5)

normal()

0.44122748688504143

normal()

-0.33087015189408764

Générer multiple

• pour se faire nous pouvons spécifier le paramétre size:

normal(size=10)

array([ 2.43077119, -0.25209213,  0.10960984,  1.58248112, -0.9092324 ,
       -0.59163666,  0.18760323, -0.32986996, -1.19276461, -0.20487651])

Cette façon de procéder est BEAUCOUP plus rapide qu'une boucle for!

• nous pouvons également spécifier plus d'une dimension:

normal(size=(5,5))

array([[-0.35882895,  0.6034716 , -1.66478853, -0.70017904,  1.15139101],
       [ 1.85733101, -1.51117956,  0.64484751, -0.98060789, -0.85685315],
       [-0.87187918, -0.42250793,  0.99643983,  0.71242127,  0.05914424],
       [-0.36331088,  0.00328884, -0.10593044,  0.79305332, -0.63157163],
       [-0.00619491, -0.10106761, -0.05230815,  0.24921766,  0.19766009]])

Histogrammes

• pour ploter un histogramme de données distribuées aléatoirement, on utilise la fonction hist() de mtplotlib:

import matplotlib.pyplot as plt
%matplotlib inline

data = normal(size=10000)
ax = plt.hist(data)

Calculer les histogrammes en matrices

• la fonction histogram() dans le module numpy compte les fréquences dans les plages et retourner le résultat sous forme d'array 2d:

import numpy as np
np.histogram(data)

(array([  23,  136,  618, 1597, 2626, 2635, 1620,  599,  130,   16], dtype=int64),
 array([-3.59780883, -2.87679609, -2.15578336, -1.43477063, -0.71375789,
         0.00725484,  0.72826758,  1.44928031,  2.17029304,  2.89130578,
         3.61231851]))

Statistiques

• nous pouvons calculer les statistiques d'un sample de données en utilisant les fonctions de numpy mean() et var()

np.mean(data)

-0.00045461080333497925

np.var(data)

1.0016048722546331

• ces fonctions ont aussi un paramètre axis pour calculer la moyenne d'arrays multidimensionnels.

Nombres aléatoires discrets

• la fonction randint() du module numpy.random peut être utilisé pour sortir des nombres aléatoires
• il prend deux paramètres: valeur basse (inclus), et valeur haute (exclue)
• pour simuler un jet de dé:

die_roll = randint(0,6)+1
die_roll

4