Apprendre Opérations Matricielles avec scipy.linalg | Algèbre linéaire et opérations matricielles

Glissez pour afficher le menu

Lorsque des opérations avancées sur les matrices sont nécessaires en Python, le module scipy.linalg offre un ensemble d’outils puissants qui complètent et étendent les fonctionnalités d’algèbre linéaire de NumPy. Bien que numpy.linalg convienne à de nombreuses tâches courantes, scipy.linalg propose des algorithmes supplémentaires, de meilleures performances pour certaines opérations, ainsi qu’un accès à des routines bas niveau issues de bibliothèques telles que BLAS et LAPACK. Cela fait de scipy.linalg un choix privilégié pour les applications scientifiques et d’ingénierie nécessitant des calculs matriciels robustes et efficaces.


              1234567891011121314151617
            
import numpy as np
from scipy.linalg import blas

# Create two matrices
A = np.array([[1, 2], [3, 4]])
B = np.array([[2, 0], [1, 2]])

# Perform matrix multiplication using BLAS's dgemm (double-precision general matrix multiply)
C = blas.dgemm(alpha=1.0, a=A, b=B)

print("Matrix A:")
print(A)
print("\nMatrix B:")
print(B)
print("\nA multiplied by B using BLAS:")
print(C)

Cet exemple de code montre comment multiplier des matrices à l’aide de scipy.linalg.blas.dgemm, qui est une interface directe vers la bibliothèque BLAS. Cette fonction est particulièrement utile lorsque des performances élevées sont requises pour la multiplication de matrices, car elle exploite des routines bas niveau optimisées.

Étant données les matrices $A$ ( $m \times k$ ) et $B$ ( $k \times n$ ), le produit $C$ ( $m \times n$ ) est calculé comme suit :

C_{ij} = \sum_{l=1}^k A_{il} B_{lj}

La fonction dgemm effectue cette opération efficacement en utilisant les routines BLAS. Il est également possible de mettre à l’échelle le résultat avec un paramètre alpha, de sorte que la matrice calculée soit :

C = \alpha \cdot A \cdot B

Utiliser dgemm permet de contrôler des paramètres spécifiques comme les facteurs d’échelle (alpha) ou de travailler avec de grands tableaux lorsque la performance est un critère essentiel.


              1234567891011121314151617181920
            
import numpy as np
from scipy.linalg import lu, solve

# Define a square matrix and a right-hand side vector
A = np.array([[3, 1, 6], [2, 1, 3], [1, 1, 1]])
b = np.array([12, 7, 3])

# Perform LU decomposition
P, L, U = lu(A)
print("Permutation matrix P:")
print(P)
print("\nLower triangular matrix L:")
print(L)
print("\nUpper triangular matrix U:")
print(U)

# Solve the linear system Ax = b
x = solve(A, b)
print("\nSolution to Ax = b:")
print(x)

Cet exemple de code illustre la décomposition LU et la résolution d’un système linéaire. La décomposition LU factorise une matrice A en trois matrices P, L et U telles que :

P A = L U

où :

P est une matrice de permutation qui prend en compte les échanges de lignes ;
L est une matrice triangulaire inférieure avec des uns sur la diagonale ;
U est une matrice triangulaire supérieure.

Cette factorisation permet de résoudre efficacement un système linéaire Ax = b. D’abord, appliquez la permutation au second membre :

P A x = L U x = P b

Soit y une variable intermédiaire. Résolvez le processus en deux étapes :

Substitution avant : Résoudre $L y = P b$ pour y ;
Substitution arrière : $U x = y$ pour x.

Cette méthode est particulièrement utile lorsqu’il faut résoudre plusieurs systèmes avec la même matrice A mais des seconds membres différents, car il suffit de calculer la décomposition LU une seule fois.

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 1

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Section 2. Chapitre 1

Opérations Matricielles avec scipy.linalg

1. Quelle est la principale différence entre scipy.linalg et numpy.linalg ?

2. Quelle fonction utiliseriez-vous pour résoudre un système d’équations linéaires dans SciPy ?

3. Quel est le but de la décomposition LU en algèbre linéaire ?