algèbre linéaire

import numpy as np

contenu de ce notebook (notebook à sauter)¶

IMPORTANT
ce notebook est utile aux enseignements de mathématiques
sachez qu’il existe pour vous y référer
sans l’étudier en cours d’informatique

liste des fonctions présentées (succinctement)

fonctions	comportement
`np.dot`	produit de matrice
`np.linalg.norm`	normes de matrice
`np.transpose`	transposition de matrice
`np.linalg.det`	déterminant
`np.linalg.inv`	inversion
`np.linalg.eig`	valeurs propres
`np.linalg.solve`	résolution de système linéaire
`np.eye`	matrice identité
`np.diag`	matrice diagonale

introduction et contexte¶

→

les fonctions d’algèbre linéaire numpy.linalg sont très efficaces, parce que

fondées sur des algorithmes efficaces
codées dans des langages bas niveau très proches de la mémoire donc rapides
implémentations qui tirent parti du multithreading
(découpage d’un programme en sous-programmes s’exécutant en même temps)

pour les différences entre les fonctions de numpy et de scipy
lire les documentations https://docs.scipy.org/doc/numpy/reference/routines.linalg.html

nous avons vu précédemment des opérations élément-par-élément comme numpy.mult(*)
nous allons voir rapidement, les fonctions dédiées à l’algèbre linéaire

la librarie numpy est utilisée dans vos cours de mathématiques
pour les manipulations de vecteurs et de matrices

aussi nous ne regardons que quelques fonctions de base en dimension < à 3

pour plus d’information, regardez la documentation

https://numpy.org/doc/stable/reference/routines.linalg.html

terminologie¶

→

on va se mettre d’accord sur les terminologies matrice, vecteur et produit

attention au type des éléments

les matrices et les vecteurs seront des numpy.ndarray
les affectations peuvent entraîner des modifications de valeurs

A = np.array([[2, 3, -7], [6, -4, 5]])
A.dtype # int64
A[0] = np.pi
A ->[[ 3,  3,  3], # A[0] vaudra 3 pas np.pi
     [ 6, -4,  5]]

A = np.array([[2, 3, -7], [6, -4, 5]])
print(A.dtype)
A[0] = np.pi
A

int64

array([[ 3,  3,  3],
       [ 6, -4,  5]])

les matrices et vecteurs¶

→

une matrice de m lignes et n colonnes

est un tableau numpy.ndarray
de dimension 2
de forme (m, n)

exemple

m, n = 4, 3
A = np.arange(12).reshape(m, n)
print(A)
print(A.ndim)   # 2
print(A.shape)  # (4, 3)

les objets de forme (1, n) et (m, 1) sont des matrices

un vecteur de taille n

est un np.ndarray
de dimension 1
de forme (n,)

exemple

V = np.array([1, -3, 8])
print(V)
print(V.ndim)
print(V.shape)

# le code
m, n = 4, 3
A = np.arange(12).reshape(m, n)
print(A)
print(A.ndim)
print(A.shape)

[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
2
(4, 3)

# le code
V = np.array([1, -3, 8])
print(V)
print(V.ndim)
print(V.shape)

[ 1 -3  8]
1
(3,)

le produit d’une matrice et d’un vecteur `numpy.dot`¶

→

$A\cdot V$

np.dot(A, V)
ou aussi A.dot(V)

matrice

m, m = 4, 3
A = np.arange(12).reshape(m, n)
A -> [[ 0  1  2]
      [ 3  4  5]
      [ 6  7  8]
      [ 9 10 11]]

vecteur

V = np.arange(3).reshape(n)
V -> [0 1 2]

produit

np.dot(A, V)
-> [ 5 14 23 32]

ou encore

A.dot(V)
-> [ 5 14 23 32]

m, n = 4, 3
A = np.arange(12).reshape(m, n)
print(A)
V = np.arange(3).reshape(n)
print(V)
print(np.dot(A, V))
print(A.dot(V))

[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
[0 1 2]
[ 5 14 23 32]
[ 5 14 23 32]

le produit de deux matrices `numpy.dot`¶

→

$A\cdot B$

np.dot(A, B)
ou aussi A.dot(B)

matrices A et B

A = np.arange(12).reshape(m, n)
A -> [[ 0  1  2]
      [ 3  4  5]
      [ 6  7  8]
      [ 9 10 11]]

B = np.arange(10, 22).reshape(n, m)
B -> [[10 11 12]
      [13 14 15]
      [16 17 18]
      [19 20 21]]

produit

np.dot(A, B)
-> [[102 108 114]
    [334 356 378]
    [566 604 642]

ou encore

A.dot(B)
-> [[102, 108, 114]
    [334, 356, 378]
    [566, 604, 642]]

# le code
m, n = 3, 4
A = np.arange(12).reshape(m, n)
print(A)
B = np.arange(10, 22).reshape(n, m)
print(B)
np.dot(A, B)
A.dot(B)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[10 11 12]
 [13 14 15]
 [16 17 18]
 [19 20 21]]

array([[102, 108, 114],
       [334, 356, 378],
       [566, 604, 642]])

produit matriciel avec `@` et `numpy.matmul`¶

→

il existe une fonction numpy.matmul
qui s’écrit aussi sous la forme @

np.matmul(A, B)

A@B

numpy.matmul et np.dot

se ressemblent en dimension 2
la multiplication par un scalaire n’est pas possible avec numpy.matmul
en dimensions supérieure à 2, leur comportement diffère complètement

préférer utiliser numpy.dot

# le code
np.matmul(A, B)
A @ B

array([[102, 108, 114],
       [334, 356, 378],
       [566, 604, 642]])

le produit scalaire¶

→

numpy.dot appliquée à deux vecteurs donne leur produit scalaire

V1 = np.array([1, -3, 8])
V1.shape # (3,)
V1 -> [ 1, -3,  8]

V2 = np.array([-6, 4, -7])
V2.shape # (3,)
V2 -> [-6 4 -7]

np.dot(V1, V2)
-> -74

V1.dot(V2)

#le code
V1 = np.array([1, -3, 8])
V1.shape # (3,)
V1

array([ 1, -3, 8])

#le code
V2 = np.array([-6, 4, -7])
V2.shape # (3,)
V2

array([-6, 4, -7])

#le code
np.dot(V1, V2)

np.int64(-74)

la norme de vecteur¶

→

prenons un vecteur $V =[v_1, ..., v_n]$

la norme np.linalg.norm(V)
est la racine carré du produit scalaire du vecteur par lui-même

$\displaystyle \left\|{ {V}}\right\|_{2}={\sqrt {v_{1}^{2}+\cdots +v_{n}^{2}}}$

un vecteur

V = np.array([1, -3, 8])

la fonction idoine

np.linalg.norm(V)
-> 8.602325267042627

autre calcul

np.sqrt(np.dot(V, V))
-> 8.602325267042627

autre calcul

np.sqrt(np.sum(V*V))
-> 8.602325267042627

pour les autres normes, regardez la documentation

https://numpy.org/doc/stable/reference/routines.linalg.html

# le code
V = np.array([1, -3, 8])
np.linalg.norm(V)
np.sqrt(np.dot(V, V))
np.sqrt(np.sum(V*V))

np.float64(8.602325267042627)

la transposée d’une matrice¶

→

fonction numpy.transpose
ou .T pour écrire des codes plus lisibles

une matrice

A = np.arange(1, 13).reshape(4, 3)
A -> [[ 1  2  3]
      [ 4  5  6]
      [ 7  8  9]
      [10 11 12]]

sa transposée

np.transpose(A)
-> [[ 1,  4,  7, 10],
    [ 2,  5,  8, 11],
    [ 3,  6,  9, 12]])

ou encore

A.T

# le code
A = np.arange(1, 13).reshape(4, 3)
print(A)
print(np.transpose(A))
print(A.T)

[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
[[ 1  4  7 10]
 [ 2  5  8 11]
 [ 3  6  9 12]]
[[ 1  4  7 10]
 [ 2  5  8 11]
 [ 3  6  9 12]]

les matrices identité¶

→

se construisent avec la fonction numpy.eye
(eye et I se prononcent pareil en anglais)

la fonction renvoie des matrices de type flottant

I = np.eye(5)
I.shape # (5, 5)
I.dtype # 'float64'
I ->  [[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]]

# le code
I = np.eye(5)
print(I.shape)
print(I.dtype)

(5, 5)
float64

le déterminant d’une matrice¶

→

la fonction numpy.linalg.det
déclenche l’exception np.linalg.LinAlgError si la matrice n’est pas carrée

une matrice carrée

A = 2*np.eye(3)
A -> [[2., 0., 0.],
      [0., 2., 0.],
      [0., 0., 2.]]

son déterminant

np.linalg.det(A)
->  7.999999999999998

tentative de calcul du déterminant sur une matrice non-carrée

B = np.array([[2, 3, 4], [5, 6, 7]])
try:
    np.linalg.det(B)
except np.linalg.LinAlgError as e:
    print(e)
-> Last 2 dimensions of the array must be square

# le code
A = 2*np.eye(3)
np.linalg.det(A)

np.float64(7.999999999999998)

#le code
B = np.array([[2, 3, 4], [5, 6, 7]])
try:
    np.linalg.det(B)
except np.linalg.LinAlgError as e:
    print(e)

Last 2 dimensions of the array must be square

les matrices diagonales¶

→

On peut créer une matrice diagonale à partir de la liste des éléments de sa diagonale

numpy.diag

sur une matrice, extrait le tableau des éléments de sa diagonale
sur une liste d’éléments, construit la matrice diagonale

la matrice

A = np.random.randint(-100, 100, size=(3, 4))
A ->  [[-11 -76  91 -97]
       [ 65  68 -40  55]
       [ 30  81 -45  28]]

sa diagonale

np.diag(A)
-> [-11  68 -45]

un vecteur
possible avec une liste Python

l = np.array([9, -45, 6])

la matrice diagonale

np.diag(l)
-> [[  9,   0,   0],
    [  0, -45,   0],
    [  0,   0,   6]]

# le code
A = np.random.randint(-100, 100, size=(3, 4))
print(A)
np.diag(A)

[[ 33 -53 -10 -23]
 [ 71  63   6 -35]
 [ 20 -76  26  27]]

array([33, 63, 26])

# le code
l = np.array([9, -45, 6])
np.diag(l)

array([[  9,   0,   0],
       [  0, -45,   0],
       [  0,   0,   6]])

la trace d’une matrice¶

→

numpy.trace fait la somme des éléments de la diagonale de la matrice

la matrice A

A = np.arange(9).reshape(3, 3)
A -> [[0, 1, 2],
      [3, 4, 5],
      [6, 7, 8]]

la trace de A

np.trace(A)
-> 12

la trace de A

np.sum(np.diag(A))
-> 12

# le code
A = np.arange(9).reshape(3, 3)
print(A)
print(np.trace(A))
print(np.sum(np.diag(A)))

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

l’inversion d’une matrice¶

→

numpy.linalg.inv(A) est le calcul de $A^{-1}$

une matrice

R = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]], dtype=float)
R -> [[0., 1., 0.],
      [0., 0., 1.],
      [1., 0., 0.]]

son inverse

np.linalg.inv(R)
-> [[0., 0., 1.],
    [1., 0., 0.],
    [0., 1., 0.]]

testons si cela fonctionne comme attendu $A^{-1}A = I$

np.all(np.dot(R, IR) == np.eye(3))
-> True

cet exemple est correct mais ce n’est pas toujours le cas
puisque les calculs informatiques sont approchés (un exemple dans la slide suivante)

# le code
R = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]], dtype=float)
print(R)
IR = np.linalg.inv(R)
print(IR)
print(np.all(np.dot(R, IR) == np.eye(3)))

[[0. 1. 0.]
 [0. 0. 1.]
 [1. 0. 0.]]
[[0. 0. 1.]
 [1. 0. 0.]
 [0. 1. 0.]]
True

calculs approchés (avec tolérance)¶

→

testons $A^{-1}A = I$ sur une matrice quelconque de floats
générés aléatoirement

A = np.random.random(size=(3, 3))
I = np.eye(len(A))      # matrice identité
A_1 = np.linalg.inv(A)
np.all(I == np.dot(A_1, A))
-> False

dans ce cas $A^{-1}A \neq I$

regardons le produit $A^{-1}A$

np.dot(A_1, A)
-> [[ 1.00000000e+00  9.47934554e-18  3.24735868e-17]
    [-2.69206416e-17  1.00000000e+00 -4.22197093e-18]
    [ 6.52983031e-18  1.58976614e-17  1.00000000e+00]]

il est très proche de $I = \begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \\ \end{bmatrix}$ mais pas exactement égal

en effet si en mathématiques on écrit $A^{-1}A = I$ , en informatique c’est plutôt $A^{-1}A \approx I$
(égal à une tolérance près)

d’ou l’intérêt de la fonction de comparaison numpy.isclose
qui effectue une comparaison de deux tableaux à une tolérance près

np.all(np.isclose(np.dot(A_1, A), I))
-> True

ça fonctionne bien comme attendu

A = np.random.random(size=(3, 3))
I = np.eye(len(A))
A_1 = np.linalg.inv(A)
np.all(I == np.dot(A_1, A))
print(np.dot(A_1, A))
np.all(np.isclose(np.dot(A_1, A), I))

[[ 1.00000000e+00 -7.13470327e-17 -7.95430430e-17]
 [ 3.41760771e-18  1.00000000e+00 -4.48302722e-18]
 [ 2.68335693e-17 -2.13714966e-17  1.00000000e+00]]

np.True_

les valeurs propres d’une matrice (eigen values)¶

→

on va calculer les $v$ tels que:

$f(v) = \lambda v$
$M \cdot v = \lambda v$ `

avec la fonction numpy.linalg.eig qui retourne

la liste des valeurs propres eigen-values
et la liste des vecteurs propres eigen-vectors

prenons une matrice M

M = np.random.random(size=(3, 3))

calculons ses valeurs et vecteurs propres M

alpha, v  = np.linalg.eig(M)
alpha.shape # (3,)
v.shape # (3, 3)

les 3 valeurs propres sont dans un vecteur
les 3 vecteurs propres forment les colonnes d’une matrice

prenons le premier vecteur propre et sa valeur propre

v0 = v[:, 0] # premier vecteur propre (première colonne)
alpha0 = alpha[0] # première valeur propre

vérifions si $M \cdot v_0 = \lambda_0 v_0$
i.e. si np.dot(M, v0) == alpha0*v0))

naturellement les calculs sont approchés
il faut utiliser l’égalité à une tolérance près

np.all(np.isclose(np.dot(M, v0),  alpha0*v0))
-> True

c’est bien ça

exercice:
parcourez les vecteurs propres et les valeurs propres
et vérifiez, pour chaque couple si $M \cdot v_i \approx \lambda_i v_i$

# le code
M = np.random.random(size=(3, 3))
alpha, v  = np.linalg.eig(M)
alpha.shape, v.shape


v0 = v[:, 0] # le premier vecteur propre
alpha0 = alpha[0] # la première valeur propre

np.all(np.isclose(np.dot(M, v0),  alpha0*v0))

np.True_

# votre code ici

résolution d’un système linéaire¶

→

on va calculer avec la fonction numpy.linalg.solve
les racines du système linéaire $A \cdot x = b$

prenons une matrice

A = np.random.random(size=(3, 3))

prenons un vecteur

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

calculons la racine de l’équation $A \cdot x = b$

x = np.linalg.solve(A, b)

vérifions si $A \cdot x \approx b$

np.all(np.isclose(np.dot(A, x), b))
-> True

une erreur numpy.linalg.LinAlgError sera levée

si elle n’est pas carrée
si la matrice n’est pas inversible

# le code
A = np.random.random(size=(3, 3))
b = np.array([1, 2, 3])
x = np.linalg.solve(A, b)
np.all(np.isclose(np.dot(A, x), b))

np.True_

numpy

exercice sur le broadcasting

TP sons

indexation avancée

contenu de ce notebook (notebook à sauter)¶

introduction et contexte¶

terminologie¶

les matrices et vecteurs¶

le produit d’une matrice et d’un vecteur numpy.dot¶

le produit de deux matrices numpy.dot¶

produit matriciel avec @ et numpy.matmul¶

le produit scalaire¶

la norme de vecteur¶

la transposée d’une matrice¶

les matrices identité¶

le déterminant d’une matrice¶

les matrices diagonales¶

la trace d’une matrice¶

l’inversion d’une matrice¶

calculs approchés (avec tolérance)¶

les valeurs propres d’une matrice (eigen values)¶

résolution d’un système linéaire¶

le produit d’une matrice et d’un vecteur `numpy.dot`¶

le produit de deux matrices `numpy.dot`¶

produit matriciel avec `@` et `numpy.matmul`¶