Algèbre linéaire NumPy

NumPy fournit une bibliothèque de fonctions d'algèbre linéairelinalg, qui contient toutes les fonctions nécessaires à l'algèbre linéaire. Vous pouvez voir la description ci-dessous :

Fonction Description
dot Produit scalaire de deux tableaux, c'est-à-dire que les éléments correspondants sont multipliés.
vdot Produit scalaire de deux vecteurs
inner Produit scalaire de deux tableaux
matmul Produit matriciel de deux tableaux
determinant Déterminant d'un tableau
solve Résoudre des équations matricielles linéaires
inv Calculer l'inverse multiplicatif d'une matrice

numpy.dot()

numpy.dot() Pour deux tableaux unidimensionnels, il calcule la somme des produits des éléments aux indices correspondants des deux tableaux (mathématiquement appelée produit scalaire de vecteurs) ; pour deux tableaux bidimensionnels, il calcule le produit matriciel des deux tableaux ; pour des tableaux multidimensionnels, sa formule de calcul générale est la suivante, c'est-à-dire que chaque élément du tableau résultant est : la somme des produits de tous les éléments de la dernière dimension du tableau a et de tous les éléments de l'avant-dernière dimension du tableau b :dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])。

numpy.dot(a, b, out=None) 

Description du paramètre :

  • a: tableau ndarray
  • b: tableau ndarray
  • out: ndarray, optionnel, utilisé pour stocker le résultat du calcul de dot()

Exemple

import numpy.matlib import numpy as np a = np.array([[1,2],[3,4]]) b = np.array([[11,12],[13,14]]) print(np.dot(a,b))

Le résultat de sortie est:

[[37  40] 
 [85  92]]

La formule de calcul est :

[[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]

numpy.vdot()

La fonction numpy.vdot() est le produit scalaire de deux vecteurs. Si le premier argument est un nombre complexe, son conjugué complexe est utilisé pour le calcul. Si l'argument est un tableau multidimensionnel, il est aplati.

Exemple

import numpy as np a = np.array([[1,2],[3,4]]) b = np.array([[11,12],[13,14]]) # vdot aplatit les tableaux et calcule le produit scalaire print (np.vdot(a,b))

Le résultat de sortie est:

130

La formule de calcul est :

1*11 + 2*12 + 3*13 + 4*14 = 130

numpy.inner()

La fonction numpy.inner() renvoie le produit scalaire de vecteurs pour des tableaux unidimensionnels. Pour les dimensions supérieures, elle renvoie la somme des produits sur les derniers axes.

Exemple

import numpy as np print (np.inner(np.array([1,2,3]),np.array([0,1,0]))) # Équivalent à 1*0+2*1+3*0

Le résultat de sortie est:

2

Exemple de tableau multidimensionnel

import numpy as np a = np.array([[1,2], [3,4]]) print ('Tableau a :') print (a) b = np.array([[11, 12], [13, 14]]) print ('Tableau b :') print (b) print ('Produit scalaire :') print (np.interne(a,b))

Le résultat de sortie est:

数组 a:
[[1 2]
 [3 4]]
数组 b:
[[11 12]
 [13 14]]
内积:
[[35 41]
 [81 95]]
数组 a:
[[1 2]
 [3 4]]
数组 b:
[[11 12]
 [13 14]]
内积:
[[35 41]
 [81 95]]

La formule de calcul du produit scalaire est :

1*11+2*12, 1*13+2*14 
3*11+4*12, 3*13+4*14

numpy.matmul

La fonction numpy.matmul renvoie le produit matriciel de deux tableaux. Bien qu'elle renvoie le produit normal de tableaux bidimensionnels, si l'un des arguments a une dimension supérieure à 2, il est traité comme une pile de matrices existant dans les deux derniers indices, et la diffusion est effectuée en conséquence.

En revanche, si l'un des arguments est un tableau unidimensionnel, il est promu en matrice en ajoutant 1 à ses dimensions, puis il est supprimé après la multiplication.

Pour les tableaux bidimensionnels, il s'agit d'une multiplication matricielle :

Exemple

import numpy.matlib import numpy as np a = [[1,0],[0,1]] b = [[4,1],[2,2]] print (np.matmul(a,b))

Le résultat de sortie est:

[[4  1] 
 [2  2]]

Opérations bidimensionnelles et unidimensionnelles :

Exemple

import numpy.matlib import numpy as np a = [[1,0],[0,1]] b = [1,2] print (np.matmul(a,b)) print (np.matmul(b,a))

Le résultat de sortie est:

[1  2] 
[1  2]

Tableaux dont les dimensions sont supérieures à deux :

Exemple

import numpy.matlib import numpy as np a = np.arange(8).reshape(2,2,2) b = np.arange(4).reshape(2,2) print (np.matmul(a,b))

Le résultat de sortie est:

[[[ 2  3]
  [ 6 11]]

 [[10 19]
  [14 27]]]

numpy.linalg.det()

La fonction numpy.linalg.det() calcule le déterminant de la matrice d'entrée.

Le déterminant est une valeur très utile en algèbre linéaire. Il est calculé à partir des éléments diagonaux d'une matrice carrée. Pour une matrice 2×2, c'est la différence entre le produit des éléments en haut à gauche et en bas à droite et le produit des deux autres.

Autrement dit, pour la matrice [[a, b], [c, d]], le déterminant est calculé comme ad-bc. Les matrices carrées plus grandes sont considérées comme des combinaisons de matrices 2×2.

Exemple

import numpy as np a = np.array([[1,2], [3,4]]) print (np.linalg.det(a))

Le résultat de sortie est:

-2.0

Exemple

import numpy as np b = np.array([[6,1,1], [4, -2, 5], [2,8,7]]) print (b) print (np.linalg.det(b)) print (6*(-2*7 - 5*8) - 1*(4*7 - 5*2) + 1*(4*8 - -2*2))

Le résultat de sortie est:

[[ 6  1  1]
 [ 4 -2  5]
 [ 2  8  7]]
-306.0
-306

numpy.linalg.solve()

La fonction numpy.linalg.solve() donne la solution d'équations linéaires sous forme matricielle.

Considérez les équations linéaires suivantes :

x + y + z = 6

2y + 5z = -4

2x + 5y - z = 27

Cela peut être exprimé sous forme matricielle comme suit :

Si les matrices sont A, X et B, l'équation devient :

AX = B

或

X = A^(-1)B

numpy.linalg.inv()

La fonction numpy.linalg.inv() calcule l'inverse multiplicatif d'une matrice.

Matrice inverse: Supposons que A soit une matrice d'ordre n sur un corps. S'il existe une autre matrice B d'ordre n sur le même corps telle que : AB=BA=E, alors on appelle B la matrice inverse de A, et A est appelée une matrice inversible. Remarque : E est la matrice identité.

Exemple

import numpy as np x = np.array([[1,2],[3,4]]) y = np.linalg.inv(x) print (x) print (y) print (np.dot(x,y))

Le résultat de sortie est:

[[1 2]
 [3 4]]
[[-2.   1. ]
 [ 1.5 -0.5]]
[[1.0000000e+00 0.0000000e+00]
 [8.8817842e-16 1.0000000e+00]]

Maintenant, créez la matrice inverse de la matrice A :

Exemple

import numpy as np a = np.array([[1,1,1],[0,2,5],[2,5,-1]]) print ('Tableau a :') print (a) ainv = np.linalg.inv(a) print ('Inverse de a :') print (ainv) print ('Matrice b :') b = np.array([[6],[-4],[27]]) print (b) print ('Calculez : A^(-1)B :') x = np.linalg.solve(a,b) print (x) # Ceci est la solution des équations linéaires x = 5, y = 3, z = -2

Le résultat de sortie est:

数组 a:
[[ 1  1  1]
 [ 0  2  5]
 [ 2  5 -1]]
a 的逆:
[[ 1.28571429 -0.28571429 -0.14285714]
 [-0.47619048  0.14285714  0.23809524]
 [ 0.19047619  0.14285714 -0.0952381 ]]
矩阵 b:
[[ 6]
 [-4]
 [27]]
计算:A^(-1)B:
[[ 5.]
 [ 3.]
 [-2.]]

Le résultat peut également être obtenu à l'aide de la fonction suivante :

x = np.dot(ainv,b)
Autres extensions