Numpy (tableaux de données multi-dimensionnels)

Librairie de calcul numérique permettant notamment de manipuler des tableaux de dimension quelconque.

In [1]:
%matplotlib inline
In [2]:
from jyquickhelper import add_notebook_menu
add_notebook_menu()
Out[2]:
run previous cell, wait for 2 seconds

Introduction

  • numpy est un module utilisé dans presque tous les projets de calcul numérique sous Python
    • Il fournit des structures de données performantes pour la manipulation de vecteurs, matrices et tenseurs plus généraux
    • numpy est écrit en C et en Fortran d'où ses performances élevées lorsque les calculs sont vectorisés (formulés comme des opérations sur des vecteurs/matrices)

Pour utiliser numpy il faut commencer par l'importer :

In [3]:
import numpy as np

Dans la terminologie numpy, vecteurs, matrices et autres tenseurs sont appelés arrays.

Création d'arrays numpy

Plusieurs possibilités:

  • à partir de listes ou n-uplets Python
  • en utilisant des fonctions dédiées, telles que arange, linspace, etc.
  • par chargement à partir de fichiers

À partir de listes

Au moyen de la fonction numpy.array :

In [4]:
# un vecteur : l'argument de la fonction est une liste Python
v = np.array([1, 3, 2, 4])
print(v)
print(type(v))
[1 3 2 4]
<class 'numpy.ndarray'>

Pour définir une matrice (array de dimension 2 pour numpy):

In [5]:
# une matrice : l'argument est une liste de liste
M = np.array([[1, 2], [3, 4]])
print(M)
[[1 2]
 [3 4]]
In [6]:
M[0, 0]
Out[6]:
1

Les objets v et M sont tous deux du type ndarray (fourni par numpy)

In [7]:
type(v), type(M)
Out[7]:
(numpy.ndarray, numpy.ndarray)

v et M ne diffèrent que par leur taille, que l'on peut obtenir via la propriété shape :

In [8]:
v.shape
Out[8]:
(4,)
In [9]:
M.shape
Out[9]:
(2, 2)

Pour obtenir le nombre d'éléments d'un array :

In [10]:
v.size
Out[10]:
4
In [11]:
M.size
Out[11]:
4

On peut aussi utiliser numpy.shape et numpy.size

In [12]:
np.shape(M)
Out[12]:
(2, 2)

Les arrays ont un type qu'on obtient via dtype:

In [13]:
print( M)
print(M.dtype)
[[1 2]
 [3 4]]
int32

Les types doivent être respectés lors d'assignations à des arrays

In [14]:
M[0,0] = "hello"
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-14-a09d72434238> in <module>()
----> 1 M[0,0] = "hello"

ValueError: invalid literal for int() with base 10: 'hello'

On peut modifier le type d'un array après sa déclaration en utilisant astype

In [15]:
a = np.array([1,2,3], dtype=np.int64)
b = np.array([2,2,3], dtype=np.int64)
b = b.astype(float)
print(a / b)
[ 0.5  1.   1. ]

On peut définir le type de manière explicite en utilisant le mot clé dtype en argument:

In [16]:
M = np.array([[1, 2], [3, 4]], dtype=complex)
M
Out[16]:
array([[ 1.+0.j,  2.+0.j],
       [ 3.+0.j,  4.+0.j]])
  • Autres types possibles avec dtype : int, float, complex, bool, object, etc.

  • On peut aussi spécifier la précision en bits: int64, int16, float128, complex128.

En utilisant des fonctions de génération d'arrays

arange

In [17]:
# create a range
x = np.arange(0, 10, 2) # arguments: start, stop, step
x
Out[17]:
array([0, 2, 4, 6, 8])
In [18]:
x = np.arange(-1, 1, 0.1)
x
Out[18]:
array([ -1.00000000e+00,  -9.00000000e-01,  -8.00000000e-01,
        -7.00000000e-01,  -6.00000000e-01,  -5.00000000e-01,
        -4.00000000e-01,  -3.00000000e-01,  -2.00000000e-01,
        -1.00000000e-01,  -2.22044605e-16,   1.00000000e-01,
         2.00000000e-01,   3.00000000e-01,   4.00000000e-01,
         5.00000000e-01,   6.00000000e-01,   7.00000000e-01,
         8.00000000e-01,   9.00000000e-01])

linspace and logspace

In [19]:
# avec linspace, le début et la fin SONT inclus
np.linspace(0, 10, 25)
Out[19]:
array([  0.        ,   0.41666667,   0.83333333,   1.25      ,
         1.66666667,   2.08333333,   2.5       ,   2.91666667,
         3.33333333,   3.75      ,   4.16666667,   4.58333333,
         5.        ,   5.41666667,   5.83333333,   6.25      ,
         6.66666667,   7.08333333,   7.5       ,   7.91666667,
         8.33333333,   8.75      ,   9.16666667,   9.58333333,  10.        ])
In [20]:
np.linspace(0, 10, 11)
Out[20]:
array([  0.,   1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.])
In [21]:
print(np.logspace(0, 10, 10, base=np.e))
[  1.00000000e+00   3.03773178e+00   9.22781435e+00   2.80316249e+01
   8.51525577e+01   2.58670631e+02   7.85771994e+02   2.38696456e+03
   7.25095809e+03   2.20264658e+04]

mgrid

In [22]:
x, y = np.mgrid[0:5, 0:5] 
In [23]:
x
Out[23]:
array([[0, 0, 0, 0, 0],
       [1, 1, 1, 1, 1],
       [2, 2, 2, 2, 2],
       [3, 3, 3, 3, 3],
       [4, 4, 4, 4, 4]])
In [24]:
y
Out[24]:
array([[0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4],
       [0, 1, 2, 3, 4]])

Données aléatoires

In [25]:
from numpy import random
In [26]:
# tirage uniforme dans [0,1]
random.rand(5,5)  # ou np.random.rand
Out[26]:
array([[ 0.6131508 ,  0.07426748,  0.57211153,  0.91746908,  0.17223215],
       [ 0.24686573,  0.74654011,  0.83246205,  0.89290663,  0.60973182],
       [ 0.52961079,  0.38182888,  0.18294348,  0.53657908,  0.09059431],
       [ 0.48215176,  0.89355443,  0.88338938,  0.65820186,  0.15033923],
       [ 0.56812463,  0.08797649,  0.13724421,  0.62676178,  0.67292051]])
In [27]:
# tirage suivant une loi normale standard
random.randn(5,5)
Out[27]:
array([[-0.41301838, -0.25846802, -0.178275  ,  0.50677525, -1.82338876],
       [ 0.0250162 ,  0.78077463, -0.43696421,  0.97714492,  1.13703047],
       [-1.47803727, -0.39024574,  1.2295068 ,  1.2190458 ,  0.18854423],
       [-1.13157322, -1.14373212, -0.97907932, -0.43690972, -0.77272979],
       [-0.5483598 ,  0.17289223, -0.26085472,  0.31824594,  0.99713851]])

diag

In [28]:
# une matrice diagonale
np.diag([1,2,3])
Out[28]:
array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])
In [29]:
# diagonale avec décalage par rapport à la diagonale principale
np.diag([1,2,3], k=1)
Out[29]:
array([[0, 1, 0, 0],
       [0, 0, 2, 0],
       [0, 0, 0, 3],
       [0, 0, 0, 0]])

zeros, ones et identity

In [30]:
np.zeros((3,), dtype=int)  # attention zeros(3,3) est FAUX
Out[30]:
array([0, 0, 0])
In [31]:
np.ones((3,3))
Out[31]:
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])
In [32]:
print(np.zeros((3,), dtype=int))
print(np.zeros((1, 3), dtype=int))
print(np.zeros((3, 1), dtype=int))
[0 0 0]
[[0 0 0]]
[[0]
 [0]
 [0]]
In [33]:
print(np.identity(3))
[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]

À partir de fichiers d'E/S

Fichiers séparés par des virgules (CSV)

Un format fichier classique est le format CSV (comma-separated values), ou bien TSV (tab-separated values). Pour lire de tels fichiers utilisez numpy.genfromtxt. Par exemple:

In [34]:
data = np.genfromtxt('DONNEES.csv', delimiter=',')
data
Out[34]:
array([[  1.,   2.,   3.,   4.,   5.],
       [  6.,   7.,   8.,   9.,  10.],
       [ 11.,  12.,  13.,  14.,  15.],
       [ 16.,  17.,  18.,  19.,  20.]])
In [35]:
data.shape
Out[35]:
(4, 5)

A l'aide de numpy.savetxt on peut enregistrer un array numpy dans un fichier txt:

In [36]:
M = random.rand(3,3)
M
Out[36]:
array([[ 0.64021422,  0.48130208,  0.03559469],
       [ 0.69735696,  0.23011688,  0.13495493],
       [ 0.76552173,  0.21839056,  0.62956912]])
In [37]:
np.savetxt("random-matrix.txt", M)
In [38]:
np.savetxt("random-matrix.csv", M, fmt='%.5f', delimiter=',') # fmt spécifie le format

Format de fichier Numpy natif

Pour sauvegarder et recharger des array numpy : numpy.save et numpy.load :

In [39]:
np.save("random-matrix.npy", M)
In [40]:
np.load("random-matrix.npy")
Out[40]:
array([[ 0.64021422,  0.48130208,  0.03559469],
       [ 0.69735696,  0.23011688,  0.13495493],
       [ 0.76552173,  0.21839056,  0.62956912]])

Autres propriétés des arrays numpy

In [41]:
M
Out[41]:
array([[ 0.64021422,  0.48130208,  0.03559469],
       [ 0.69735696,  0.23011688,  0.13495493],
       [ 0.76552173,  0.21839056,  0.62956912]])
In [42]:
M.dtype
Out[42]:
dtype('float64')
In [43]:
M.itemsize # octets par élément
Out[43]:
8
In [44]:
M.nbytes # nombre d'octets
Out[44]:
72
In [45]:
M.nbytes / M.size
Out[45]:
8.0
In [46]:
M.ndim # nombre de dimensions
Out[46]:
2
In [47]:
print(np.zeros((3,), dtype=int).ndim)
print( np.zeros((1, 3), dtype=int).ndim)
print (np.zeros((3, 1), dtype=int).ndim)
1
2
2

Manipulation et Opérations sur les arrays

Indexation

In [48]:
# v est un vecteur, il n'a qu'une seule dimension -> un seul indice
v[0]
Out[48]:
1
In [49]:
# M est une matrice, ou un array à 2 dimensions -> deux indices 
M[1,1]
Out[49]:
0.23011687711097661

Contenu complet :

In [50]:
M
Out[50]:
array([[ 0.64021422,  0.48130208,  0.03559469],
       [ 0.69735696,  0.23011688,  0.13495493],
       [ 0.76552173,  0.21839056,  0.62956912]])

La deuxième ligne :

In [51]:
M[1]
Out[51]:
array([ 0.69735696,  0.23011688,  0.13495493])

On peut aussi utiliser :

In [52]:
M[1,:] # 2 ème ligne (indice 1)
Out[52]:
array([ 0.69735696,  0.23011688,  0.13495493])
In [53]:
M[:,1] # 2 ème colonne (indice 1)
Out[53]:
array([ 0.48130208,  0.23011688,  0.21839056])
In [54]:
print(M.shape)
print( M[1,:].shape, M[:,1].shape)
(3, 3)
(3,) (3,)

On peut assigner des nouvelles valeurs à certaines cellules :

In [55]:
M[0,0] = 1
In [56]:
M
Out[56]:
array([[ 1.        ,  0.48130208,  0.03559469],
       [ 0.69735696,  0.23011688,  0.13495493],
       [ 0.76552173,  0.21839056,  0.62956912]])
In [57]:
# on peut aussi assigner des lignes ou des colonnes
M[1,:] = -1
# M[1,:] = [1, 2, 3]
In [58]:
M
Out[58]:
array([[ 1.        ,  0.48130208,  0.03559469],
       [-1.        , -1.        , -1.        ],
       [ 0.76552173,  0.21839056,  0.62956912]])

Slicing ou accès par tranches

Slicing fait référence à la syntaxe M[start:stop:step] pour extraire une partie d'un array :

In [59]:
A = np.array([1,2,3,4,5])
A
Out[59]:
array([1, 2, 3, 4, 5])
In [60]:
A[1:3]
Out[60]:
array([2, 3])

Les tranches sont modifiables :

In [61]:
A[1:3] = [-2,-3]
A
Out[61]:
array([ 1, -2, -3,  4,  5])

On peut omettre n'importe lequel des argument dans M[start:stop:step]:

In [62]:
A[::] # indices de début, fin, et pas avec leurs valeurs par défaut
Out[62]:
array([ 1, -2, -3,  4,  5])
In [63]:
A[::2] # pas = 2, indices de début et de fin par défaut
Out[63]:
array([ 1, -3,  5])
In [64]:
A[:3] # les trois premiers éléments
Out[64]:
array([ 1, -2, -3])
In [65]:
A[3:] # à partir de l'indice 3
Out[65]:
array([4, 5])
In [66]:
M = np.arange(12).reshape(4, 3)
print( M)
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]

On peut utiliser des indices négatifs :

In [67]:
A = np.array([1,2,3,4,5])
In [68]:
A[-1] # le dernier élément
Out[68]:
5
In [69]:
A[-3:] # les 3 derniers éléments
Out[69]:
array([3, 4, 5])

Le slicing fonctionne de façon similaire pour les array multi-dimensionnels

In [70]:
A = np.array([[n+m*10 for n in range(5)] for m in range(5)])

A
Out[70]:
array([[ 0,  1,  2,  3,  4],
       [10, 11, 12, 13, 14],
       [20, 21, 22, 23, 24],
       [30, 31, 32, 33, 34],
       [40, 41, 42, 43, 44]])
In [71]:
A[1:4, 1:4]  # sous-tableau
Out[71]:
array([[11, 12, 13],
       [21, 22, 23],
       [31, 32, 33]])
In [72]:
# sauts
A[::2, ::2]
Out[72]:
array([[ 0,  2,  4],
       [20, 22, 24],
       [40, 42, 44]])
In [73]:
A
Out[73]:
array([[ 0,  1,  2,  3,  4],
       [10, 11, 12, 13, 14],
       [20, 21, 22, 23, 24],
       [30, 31, 32, 33, 34],
       [40, 41, 42, 43, 44]])
In [74]:
A[[0, 1, 3]]
Out[74]:
array([[ 0,  1,  2,  3,  4],
       [10, 11, 12, 13, 14],
       [30, 31, 32, 33, 34]])

Indexation avancée (fancy indexing)

Lorsque qu'on utilise des listes ou des array pour définir des tranches :

In [75]:
row_indices = [1, 2, 4]
print( A)
print("\n")
print ( A[row_indices])
# print( A.shape)
[[ 0  1  2  3  4]
 [10 11 12 13 14]
 [20 21 22 23 24]
 [30 31 32 33 34]
 [40 41 42 43 44]]


[[10 11 12 13 14]
 [20 21 22 23 24]
 [40 41 42 43 44]]
In [76]:
A[[1, 2]][:, [3, 4]] = 0  # ATTENTION !
print( A)
[[ 0  1  2  3  4]
 [10 11 12 13 14]
 [20 21 22 23 24]
 [30 31 32 33 34]
 [40 41 42 43 44]]
In [77]:
print ( A[[1, 2], [3, 4]])
[13 24]
In [78]:
A[np.ix_([1, 2], [3, 4])] = 0
print ( A)
[[ 0  1  2  3  4]
 [10 11 12  0  0]
 [20 21 22  0  0]
 [30 31 32 33 34]
 [40 41 42 43 44]]

On peut aussi utiliser des masques binaires :

In [79]:
B = np.arange(5)
B
Out[79]:
array([0, 1, 2, 3, 4])
In [80]:
row_mask = np.array([True, False, True, False, False])
print(  B[row_mask])
print(  B[[0,2]])
[0 2]
[0 2]
In [81]:
# de façon équivalente
row_mask = np.array([1,0,1,0,0], dtype=bool)
B[row_mask]
Out[81]:
array([0, 2])
In [82]:
# ou encore
a = np.array([1, 2, 3, 4, 5])
print(  a < 3)
print(  B[a < 3])
[ True  True False False False]
[0 1]
In [83]:
print(  A,"\n")
print(  A[:, a < 3])
[[ 0  1  2  3  4]
 [10 11 12  0  0]
 [20 21 22  0  0]
 [30 31 32 33 34]
 [40 41 42 43 44]] 

[[ 0  1]
 [10 11]
 [20 21]
 [30 31]
 [40 41]]

Opérations élément par élément

On déclare aa et bb sur lesquelles nous allons illustrer quelques opérations

In [84]:
a = np.ones((3,2))
b = np.arange(6).reshape(a.shape)
print(a)
b
[[ 1.  1.]
 [ 1.  1.]
 [ 1.  1.]]
Out[84]:
array([[0, 1],
       [2, 3],
       [4, 5]])

Les opérations arithmétiques avec les scalaires, ou entre arrays s'effectuent élément par élément. Lorsque le dtype n'est pas le même ( aa contient des float, bb contient des int), numpy adopte le type le plus "grand" (au sens de l'inclusion).

In [85]:
print( (a + b)**2 )
print( np.abs( 3*a - b ) )
f = lambda x: np.exp(x-1)
print( f(b) )
[[  1.   4.]
 [  9.  16.]
 [ 25.  36.]]
[[ 3.  2.]
 [ 1.  0.]
 [ 1.  2.]]
[[  0.36787944   1.        ]
 [  2.71828183   7.3890561 ]
 [ 20.08553692  54.59815003]]
In [86]:
1/b
C:\Users\Fait_\Anaconda3\lib\site-packages\ipykernel\__main__.py:1: RuntimeWarning: divide by zero encountered in true_divide
  if __name__ == '__main__':
Out[86]:
array([[        inf,  1.        ],
       [ 0.5       ,  0.33333333],
       [ 0.25      ,  0.2       ]])

Broadcasting

Que se passe-t-il si les dimensions sont différentes?

In [87]:
c = np.ones(6)
c
Out[87]:
array([ 1.,  1.,  1.,  1.,  1.,  1.])
In [88]:
b+c   # déclenche une exception
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-88-882b3e9536b7> in <module>()
----> 1 b+c   # déclenche une exception

ValueError: operands could not be broadcast together with shapes (3,2) (6,) 
In [89]:
c = np.arange(3).reshape((3,1))
print(b,c, sep='\n\n')
b+c
[[0 1]
 [2 3]
 [4 5]]

[[0]
 [1]
 [2]]
Out[89]:
array([[0, 1],
       [3, 4],
       [6, 7]])

L'opération précédente fonctionne car numpy effectue ce qu'on appelle un broadcasting de c : une dimension étant commune, tout se passe comme si on dupliquait c sur la dimension non-partagée avec b. Vous trouverez une explication visuelle simple ici :

In [90]:
a = np.zeros((3,3))
a[:,0] = -1
b = np.array(range(3))
print(a + b)
[[-1.  1.  2.]
 [-1.  1.  2.]
 [-1.  1.  2.]]

Extraction de données à partir d'arrays et création d'arrays

where

Un masque binaire peut être converti en indices de positions avec where

In [91]:
x = np.arange(0, 10, 0.5)
print ( x)
mask = (x > 5) * (x < 7.5)
print(  mask)
indices = np.where(mask)
indices
[ 0.   0.5  1.   1.5  2.   2.5  3.   3.5  4.   4.5  5.   5.5  6.   6.5  7.
  7.5  8.   8.5  9.   9.5]
[False False False False False False False False False False False  True
  True  True  True False False False False False]
Out[91]:
(array([11, 12, 13, 14], dtype=int64),)
In [92]:
x[indices] # équivalent à x[mask]
Out[92]:
array([ 5.5,  6. ,  6.5,  7. ])

diag

Extraire la diagonale ou une sous-diagonale d'un array :

In [93]:
print ( A)
np.diag(A)
[[ 0  1  2  3  4]
 [10 11 12  0  0]
 [20 21 22  0  0]
 [30 31 32 33 34]
 [40 41 42 43 44]]
Out[93]:
array([ 0, 11, 22, 33, 44])
In [94]:
np.diag(A, -1)
Out[94]:
array([10, 21, 32, 43])

Algèbre linéaire

La performance des programmes écrit en Python/Numpy dépend de la capacité à vectoriser les calculs (les écrire comme des opérations sur des vecteurs/matrices) en évitant au maximum les boucles for/while.

Vous avez un éventail de fonctions pour faire de l'algèbre linéaire dans numpy ou dans scipy. Cela peut vous servir si vous cherchez à faire une décomposition matricielle particulière (LU, QR, SVD,...), si vous vous intéressez aux valeurs propres d'une matrice, etc...

Opérations scalaires

On peut effectuer les opérations arithmétiques habituelles pour multiplier, additionner, soustraire et diviser des arrays avec/par des scalaires :

In [95]:
v1 = np.arange(0, 5)
print (v1)
[0 1 2 3 4]
In [96]:
v1 * 2
Out[96]:
array([0, 2, 4, 6, 8])
In [97]:
v1 + 2
Out[97]:
array([2, 3, 4, 5, 6])
In [98]:
A = np.array([[n+m*10 for n in range(5)] for m in range(5)])
print(  A)
[[ 0  1  2  3  4]
 [10 11 12 13 14]
 [20 21 22 23 24]
 [30 31 32 33 34]
 [40 41 42 43 44]]
In [99]:
print(  A * 2)
[[ 0  2  4  6  8]
 [20 22 24 26 28]
 [40 42 44 46 48]
 [60 62 64 66 68]
 [80 82 84 86 88]]
In [100]:
print(  A + 2)
[[ 2  3  4  5  6]
 [12 13 14 15 16]
 [22 23 24 25 26]
 [32 33 34 35 36]
 [42 43 44 45 46]]

Opérations terme-à-terme sur les arrays

Les opérations par défaut sont des opérations terme-à-terme :

In [101]:
A = np.array([[n+m*10 for n in range(5)] for m in range(5)])
print ( A)
[[ 0  1  2  3  4]
 [10 11 12 13 14]
 [20 21 22 23 24]
 [30 31 32 33 34]
 [40 41 42 43 44]]
In [102]:
A * A # multiplication terme-à-terme
Out[102]:
array([[   0,    1,    4,    9,   16],
       [ 100,  121,  144,  169,  196],
       [ 400,  441,  484,  529,  576],
       [ 900,  961, 1024, 1089, 1156],
       [1600, 1681, 1764, 1849, 1936]])
In [103]:
(A + A.T) / 2
Out[103]:
array([[  0. ,   5.5,  11. ,  16.5,  22. ],
       [  5.5,  11. ,  16.5,  22. ,  27.5],
       [ 11. ,  16.5,  22. ,  27.5,  33. ],
       [ 16.5,  22. ,  27.5,  33. ,  38.5],
       [ 22. ,  27.5,  33. ,  38.5,  44. ]])
In [104]:
print(  v1)
print(  v1 * v1)
[0 1 2 3 4]
[ 0  1  4  9 16]

En multipliant des arrays de tailles compatibles, on obtient des multiplications terme-à-terme par ligne :

In [105]:
A.shape, v1.shape
Out[105]:
((5, 5), (5,))
In [106]:
print(  A)
print(  v1)
print(  A * v1)
[[ 0  1  2  3  4]
 [10 11 12 13 14]
 [20 21 22 23 24]
 [30 31 32 33 34]
 [40 41 42 43 44]]
[0 1 2 3 4]
[[  0   1   4   9  16]
 [  0  11  24  39  56]
 [  0  21  44  69  96]
 [  0  31  64  99 136]
 [  0  41  84 129 176]]

Algèbre matricielle

Comment faire des multiplications de matrices ? Deux façons :

  • en utilisant les fonctions dot;
  • en utiliser le type matrix.
In [107]:
print( A.shape)
print( A)
print( type(A))
(5, 5)
[[ 0  1  2  3  4]
 [10 11 12 13 14]
 [20 21 22 23 24]
 [30 31 32 33 34]
 [40 41 42 43 44]]
<class 'numpy.ndarray'>
In [108]:
print( np.dot(A, A))  # multiplication matrice
print( A * A ) # multiplication élément par élément
[[ 300  310  320  330  340]
 [1300 1360 1420 1480 1540]
 [2300 2410 2520 2630 2740]
 [3300 3460 3620 3780 3940]
 [4300 4510 4720 4930 5140]]
[[   0    1    4    9   16]
 [ 100  121  144  169  196]
 [ 400  441  484  529  576]
 [ 900  961 1024 1089 1156]
 [1600 1681 1764 1849 1936]]
In [109]:
A.dot(v1)
Out[109]:
array([ 30, 130, 230, 330, 430])
In [110]:
np.dot(v1, v1)
Out[110]:
30

Avec le type matrix de Numpy

In [111]:
M = np.matrix(A)
v = np.matrix(v1).T # en faire un vecteur colonne
In [112]:
M * v
Out[112]:
matrix([[ 30],
        [130],
        [230],
        [330],
        [430]])
In [113]:
# produit scalaire
v.T * v
Out[113]:
matrix([[30]])
In [114]:
# avec les objets matrices, c'est les opérations standards sur les matrices qui sont appliquées
v + M*v
Out[114]:
matrix([[ 30],
        [131],
        [232],
        [333],
        [434]])

Si les dimensions sont incompatibles on provoque des erreurs :

In [115]:
v = np.matrix([1,2,3,4,5,6]).T
In [116]:
np.shape(M), np.shape(v)
Out[116]:
((5, 5), (6, 1))
In [117]:
M * v
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-117-995fb48ad0cc> in <module>()
----> 1 M * v

C:\Users\Fait_\Anaconda3\lib\site-packages\numpy\matrixlib\defmatrix.py in __mul__(self, other)
    341         if isinstance(other, (N.ndarray, list, tuple)) :
    342             # This promotes 1-D vectors to row vectors
--> 343             return N.dot(self, asmatrix(other))
    344         if isscalar(other) or not hasattr(other, '__rmul__') :
    345             return N.dot(self, other)

ValueError: shapes (5,5) and (6,1) not aligned: 5 (dim 1) != 6 (dim 0)

Voir également les fonctions : inner, outer, cross, kron, tensordot. Utiliser par exemple help(kron).

On peut calculer l'inverse ou le déterminant de $A$

In [118]:
A = np.tril(np.ones((3,3)))
b = np.diag([1,2, 3])
print(A)
print("-------")
print(np.linalg.det(A))  # déterminant de la matrice A
print("-------")
inv_A = np.linalg.inv(A)   # inverse de la matrice A
print(inv_A)
print("-------")
print(inv_A.dot(A))
[[ 1.  0.  0.]
 [ 1.  1.  0.]
 [ 1.  1.  1.]]
-------
1.0
-------
[[ 1.  0.  0.]
 [-1.  1.  0.]
 [ 0. -1.  1.]]
-------
[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]

... résoudre des systèmes d'equations linéaires du type $Ax=b$ ...

In [119]:
x = np.linalg.solve(A, np.diag(b))
print(np.diag(b))
print(x)
print(A.dot(x))
[1 2 3]
[ 1.  1.  1.]
[ 1.  2.  3.]

... ou encore obtenir les valeurs propres de $A$

In [120]:
np.linalg.eig(A)
Out[120]:
(array([ 1.,  1.,  1.]),
 array([[  0.00000000e+00,   0.00000000e+00,   4.93038066e-32],
        [  0.00000000e+00,   2.22044605e-16,  -2.22044605e-16],
        [  1.00000000e+00,  -1.00000000e+00,   1.00000000e+00]]))
In [121]:
np.linalg.eigvals(A)
Out[121]:
array([ 1.,  1.,  1.])

Transformations d'arrays ou de matrices

  • Plus haut .T a été utilisé pour transposer l'objet matrice v
  • On peut aussi utiliser la fonction transpose

Autres transformations :

In [122]:
C = np.matrix([[1j, 2j], [3j, 4j]])
C
Out[122]:
matrix([[ 0.+1.j,  0.+2.j],
        [ 0.+3.j,  0.+4.j]])
In [123]:
np.conjugate(C)
Out[123]:
matrix([[ 0.-1.j,  0.-2.j],
        [ 0.-3.j,  0.-4.j]])

Transposée conjuguée :

In [124]:
C.H
Out[124]:
matrix([[ 0.-1.j,  0.-3.j],
        [ 0.-2.j,  0.-4.j]])

Parties réelles et imaginaires :

In [125]:
np.real(C) # same as: C.real
Out[125]:
matrix([[ 0.,  0.],
        [ 0.,  0.]])
In [126]:
np.imag(C) # same as: C.imag
Out[126]:
matrix([[ 1.,  2.],
        [ 3.,  4.]])

Argument et module :

In [127]:
np.angle(C+1) 
Out[127]:
array([[ 0.78539816,  1.10714872],
       [ 1.24904577,  1.32581766]])
In [128]:
np.abs(C)
Out[128]:
matrix([[ 1.,  2.],
        [ 3.,  4.]])

Caclul matriciel

Analyse de données

Numpy propose des fonctions pour calculer certaines statistiques des données stockées dans des arrays :

In [129]:
data = np.vander([1, 2, 3, 4])
print( data)
print( data.shape)
[[ 1  1  1  1]
 [ 8  4  2  1]
 [27  9  3  1]
 [64 16  4  1]]
(4, 4)

mean

In [130]:
# np.mean(data)
print( np.mean(data, axis=0))
[ 25.    7.5   2.5   1. ]
In [131]:
# la moyenne de la troisième colonne
np.mean(data[:,2])
Out[131]:
2.5

variance et écart type

In [132]:
np.var(data[:,2]), np.std(data[:,2])
Out[132]:
(1.25, 1.1180339887498949)

min et max

In [133]:
data[:,2].min()
Out[133]:
1
In [134]:
data[:,2].max()
Out[134]:
4
In [135]:
data[:,2].sum()
Out[135]:
10
In [136]:
data[:,2].prod()
Out[136]:
24

sum, prod, et trace

In [137]:
d = np.arange(0, 10)
d
Out[137]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [138]:
# somme des éléments
np.sum(d)
Out[138]:
45

ou encore :

In [139]:
d.sum()
Out[139]:
45
In [140]:
# produit des éléments
np.prod(d+1)
Out[140]:
3628800
In [141]:
# somme cumulée
np.cumsum(d)
Out[141]:
array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45], dtype=int32)
In [142]:
# produit cumulé
np.cumprod(d+1)
Out[142]:
array([      1,       2,       6,      24,     120,     720,    5040,
         40320,  362880, 3628800], dtype=int32)
In [143]:
# équivalent à diag(A).sum()
np.trace(data)
Out[143]:
9

Calculs avec parties d'arrays

en utilisant l'indexation ou n'importe quelle méthode d'extraction de donnés à partir des arrays

In [144]:
data
Out[144]:
array([[ 1,  1,  1,  1],
       [ 8,  4,  2,  1],
       [27,  9,  3,  1],
       [64, 16,  4,  1]])
In [145]:
np.unique(data[:,1]) 
Out[145]:
array([ 1,  4,  9, 16])
In [146]:
mask = data[:,1] == 4
In [147]:
np.mean(data[mask,3])
Out[147]:
1.0

Calculs avec données multi-dimensionnelles

Pour appliquer min, max, etc., par lignes ou colonnes :

In [148]:
m = random.rand(3,4)
m
Out[148]:
array([[ 0.42194068,  0.81311583,  0.8793851 ,  0.04085579],
       [ 0.87255324,  0.07847906,  0.02123014,  0.42960791],
       [ 0.45020951,  0.92117042,  0.41287122,  0.68794805]])
In [149]:
# max global 
m.max()
Out[149]:
0.92117041643426589
In [150]:
# max dans chaque colonne
m.max(axis=0)
Out[150]:
array([ 0.87255324,  0.92117042,  0.8793851 ,  0.68794805])
In [151]:
# max dans chaque ligne
m.max(axis=1)
Out[151]:
array([ 0.8793851 ,  0.87255324,  0.92117042])

Plusieurs autres méthodes des classes array et matrix acceptent l'argument (optional) axis keyword argument.

Génération de nombres aléatoires et statistiques

Le module : numpy.random apporte à python la possibilité de générer un échantillon de taille nn directement, alors que le module natif de python ne produit des tirages que un par un. Le module numpy.random est donc bien plus efficace si on veut tirer des échantillon conséquents. Par ailleurs, scipy.stats fournit des méthodes pour un très grand nombre de distributions et quelques fonctions classiques de statistiques.

Par exemple, on peut obtenir un array 4x3 de tirages gaussiens standard (soit en utilisant randn ou normal :

In [152]:
np.random.randn(4,3)
Out[152]:
array([[ 0.58994327, -1.57685873, -1.5537326 ],
       [-2.74018273,  0.56567855, -1.24439932],
       [ 0.31915681,  1.87745501,  0.99381417],
       [-0.1008603 , -0.47430235,  0.47587816]])

Pour se convaincre que numpy.random est plus efficace que le module random de base de python. On effectue un grand nombre de tirages gaussiens standard, en python pur et via numpy.

In [158]:
N = int(1e7)
from random import normalvariate
%timeit [normalvariate(0,1) for _ in range(N)]
1 loop, best of 3: 10.9 s per loop
In [159]:
%timeit np.random.randn(N)
1 loop, best of 3: 376 ms per loop

Copy et "deep copy"

Pour des raisons de performance Python ne copie pas automatiquement les objets (par exemple passage par référence des paramètres de fonctions).

In [155]:
A = np.array([[0,  2],[ 3,  4]])
A
Out[155]:
array([[0, 2],
       [3, 4]])
In [156]:
B = A
In [157]:
# changer B affecte A
B[0,0] = 10
B
Out[157]:
array([[10,  2],
       [ 3,  4]])
In [130]:
A
Out[130]:
array([[10,  2],
       [ 3,  4]])
In [132]:
B = A
print( B is A)
True

Pour éviter ce comportement, on peut demander une copie profonde (deep copy) de A dans B

In [133]:
#B = np.copy(A)
B = A.copy()
In [134]:
# maintenant en modifiant B, A n'est plus affecté
B[0,0] = -5

B
Out[134]:
array([[-5,  2],
       [ 3,  4]])
In [135]:
A  # A est aussi modifié !
Out[135]:
array([[10,  2],
       [ 3,  4]])
In [136]:
print( A - A[:,0] ) # FAUX
print (A - A[:,0].reshape((2, 1)))  # OK
[[ 0 -1]
 [-7  1]]
[[ 0 -8]
 [ 0  1]]

Changement de forme et de taille, et concaténation des arrays

In [137]:
A
Out[137]:
array([[10,  2],
       [ 3,  4]])
In [138]:
n, m = A.shape
In [139]:
B = A.reshape((1,n*m))
B
Out[139]:
array([[10,  2,  3,  4]])
In [140]:
B[0,0:5] = 5 # modifier l'array

B
Out[140]:
array([[5, 5, 5, 5]])
In [141]:
A
Out[141]:
array([[5, 5],
       [5, 5]])

Attention !

La variable originale est aussi modifiée ! B n'est qu'une nouvelle vue de A.

Pour transformer un array multi-dimmensionel en un vecteur. Mais cette fois-ci, une copie des données est créée :

In [142]:
B = A.flatten()
B
Out[142]:
array([5, 5, 5, 5])
In [143]:
B[0:5] = 10
B
Out[143]:
array([10, 10, 10, 10])
In [144]:
A # A ne change pas car B est une copie de A
Out[144]:
array([[5, 5],
       [5, 5]])

Ajouter une nouvelle dimension avec newaxis

par exemple pour convertir un vecteur en une matrice ligne ou colonne :

In [145]:
v = np.array([1,2,3])
In [146]:
np.shape(v)
Out[146]:
(3,)
In [149]:
# créer une matrice à une colonne à partir du vectuer v
v[:, np.newaxis]
Out[149]:
array([[1],
       [2],
       [3]])
In [150]:
v[:,np.newaxis].shape
Out[150]:
(3, 1)
In [151]:
# matrice à une ligne
v[np.newaxis,:].shape
Out[151]:
(1, 3)

Concaténer, répéter des arrays

En utilisant les fonctions repeat, tile, vstack, hstack, et concatenate, on peut créer des vecteurs/matrices plus grandes à partir de vecteurs/matrices plus petites :

repeat et tile

In [152]:
a = np.array([[1, 2], [3, 4]])
a
Out[152]:
array([[1, 2],
       [3, 4]])
In [153]:
# répéter chaque élément 3 fois
np.repeat(a, 3) # résultat 1-d
Out[153]:
array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])
In [154]:
# on peut spécifier l'argument axis
np.repeat(a, 3, axis=1)
Out[154]:
array([[1, 1, 1, 2, 2, 2],
       [3, 3, 3, 4, 4, 4]])

Pour répéter la matrice, il faut utiliser tile

In [155]:
# répéter la matrice 3 fois
np.tile(a, 3)
Out[155]:
array([[1, 2, 1, 2, 1, 2],
       [3, 4, 3, 4, 3, 4]])

concatenate

In [156]:
b = np.array([[5, 6]])
In [157]:
np.concatenate((a, b), axis=0)
Out[157]:
array([[1, 2],
       [3, 4],
       [5, 6]])
In [158]:
np.concatenate((a, b.T), axis=1)
Out[158]:
array([[1, 2, 5],
       [3, 4, 6]])

hstack et vstack

In [159]:
np.vstack((a,b))
Out[159]:
array([[1, 2],
       [3, 4],
       [5, 6]])
In [160]:
np.hstack((a,b.T))
Out[160]:
array([[1, 2, 5],
       [3, 4, 6]])

Itérer sur les éléments d'un array

  • Dans la mesure du possible, il faut éviter l'itération sur les éléments d'un array : c'est beaucoup plus lent que les opérations vectorisées
  • Mais il arrive que l'on n'ait pas le choix...
In [161]:
v = np.array([1,2,3,4])

for element in v:
    print(element)
1
2
3
4
In [162]:
M = np.array([[1,2], [3,4]])

for row in M:
    print ("row", row)
    
    for element in row:
        print( element)
row [1 2]
1
2
row [3 4]
3
4

Pour obtenir les indices des éléments sur lesquels on itère (par exemple, pour pouvoir les modifier en même temps) on peut utiliser enumerate :

In [163]:
for row_idx, row in enumerate(M):
    print ("row_idx", row_idx, "row", row)
    
    for col_idx, element in enumerate(row):
        print( "col_idx", col_idx, "element", element)
       
        # update the matrix M: square each element
        M[row_idx, col_idx] = element ** 2
row_idx 0 row [1 2]
col_idx 0 element 1
col_idx 1 element 2
row_idx 1 row [3 4]
col_idx 0 element 3
col_idx 1 element 4
In [164]:
# chaque élément de M a maintenant été élevé au carré
M
Out[164]:
array([[ 1,  4],
       [ 9, 16]])

Utilisation d'arrays dans des conditions

Losqu'on s'intéresse à des conditions sur tout on une partie d'un array, on peut utiliser any ou all :

In [165]:
M
Out[165]:
array([[ 1,  4],
       [ 9, 16]])
In [166]:
if (M > 5).any():
    print( "au moins un élément de M est plus grand que 5")
else:
    print ("aucun élément de M n'est plus grand que 5")
au moins un élément de M est plus grand que 5
In [168]:
if (M > 5).all():
    print ("tous les éléments de M sont plus grands que 5")
else:
    print( "tous les éléments de M sont plus petits que 5")
tous les éléments de M sont plus petits que 5

Type casting

On peut créer une vue d'un autre type que l'original pour un array

In [170]:
M =np.array([[-1,2], [0,4]])
M.dtype
Out[170]:
dtype('int32')
In [171]:
M2 = M.astype(float)
M2
Out[171]:
array([[-1.,  2.],
       [ 0.,  4.]])
In [172]:
M2.dtype
Out[172]:
dtype('float64')
In [173]:
M3 = M.astype(bool)
M3
Out[173]:
array([[ True,  True],
       [False,  True]], dtype=bool)