(Mémorandum comme mesure de qualification électronique)
Par exemple, créez $ A = \ begin {pmatrix} 1 & 1 \\ 2 & 4 \\ 3 & 1 \ end {pmatrix} $ avec 3 lignes et 2 colonnes.
>>> A=np.array([[1,1],[2,4],[3,1]])
>>>
>>> A
array([[1, 1],
[2, 4],
[3, 1]])
Dans l'exemple suivant, obtenez le nombre de lignes et de colonnes avec la forme et obtenez le nombre total d'éléments avec la taille.
>>> A=np.array([[1,2,3],[4,3,2]])
>>>
>>> A.shape ##Nombre de lignes / colonnes
(2, 3)
>>>
>>> A.shape[0] ##Le nombre de lignes et de colonnes peut être affiché séparément.
2
>>>
>>> A.shape[1]
3
>>> row, col = A.shape ##Le nombre de lignes et de colonnes peut être défini pour séparer les variables
>>>
>>> row
2
>>>
>>> col
3
Une matrice dans laquelle le nombre d'éléments de ligne et le nombre d'éléments de colonne correspondent. La taille est de n lignes et n colonnes et devient une forme carrée
Dans l'exemple ci-dessous, $ A = \ begin {pmatrix} 1 & 2 & 3 \\ 4 & 3 & 2 \ end {pmatrix} $ et $ \ begin {pmatrix} 1 & 2 \\ 2 & 3 \ end {pmatrix } Trouvez le nombre de lignes $ .shape [0] $ et le nombre de colonnes $ .shape [1] $ avec les deux $, et comparez les valeurs pour déterminer s'il s'agit d'une matrice carrée. $ B $ est True et une matrice carrée.
>>> A=np.array([[1,2,3],[4,3,2]])
>>>
>>> np.array_equal(A.shape[0],A.shape[1])
False
>>>
>>> B=np.array([[1,1],[2,4]])
>>>
>>> np.array_equal(B.shape[0],B.shape[1])
True
L'exemple 1 crée une matrice 1 par 3 en utilisant des nombres aléatoires L'exemple 2 crée une matrice 2 par 3 en utilisant des entiers aléatoires jusqu'à 3-6 (sans compter 7)
>>> np.random.rand(3) ###Exemple 1
array([0.4449089 , 0.70920233, 0.59915992])
>>> np.random.randint(3,7,size=(2,3)) ###Exemple 2
array([[3, 6, 4],
[5, 3, 6]])
Créer une matrice avec tous les éléments 0
Par exemple, créez une matrice zéro 2 par 2 $ W = \ begin {pmatrix} 0 & 0 \\ 0 & 0 \ end {pmatrix} $
>>> W=np.zeros((2,2,))
>>>
>>> W
array([[0., 0.],
[0., 0.]])
Par exemple, créez $ W = \ begin {pmatrix} 1 & 1 \\ 1 & 1 \ end {pmatrix} $ où tous les éléments sur 2 lignes et 2 colonnes valent 1.
>>> W=np.ones((2,2,))
>>>
>>> W
array([[1., 1.],
[1., 1.]])
Tous les éléments de la diagonale principale sont 1 et tous les autres sont 0. Le symbole est indiqué par $ E $.
Par exemple, créez $ E = \ begin {pmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \ end {pmatrix} $ sur 3 lignes et 3 colonnes.
>>> E = np.eye(3)
>>>
>>> E
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
Une matrice de $ n $ row $ m $ colonne qui peut être créée en échangeant les éléments de la matrice de colonne $ m $ row $ n $. La matrice transposée est représentée par $ A ^ {T} $ pour la matrice $ A $
Par exemple, $ \ begin {pmatrix} 2 & 3 & 1 \\ 5 & 7 & 0 \ end {pmatrix} $ translocation matrix $ \ begin {pmatrix} 2 & 5 \\ 3 & 7 \\ 1 & Rechercher 0 \ end {pmatrix} $
>>> A=np.array([[2,3,1],[5,7,0]])
>>>
>>> A
array([[2, 3, 1],
[5, 7, 0]])
>>>
>>> AT=A.T
>>>
>>> AT
array([[2, 5],
[3, 7],
[1, 0]])
Une matrice carrée qui correspond à sa propre matrice de translocation Pour la matrice $ A $, $ A = A ^ {T} $.
L'exemple suivant recherche et compare $ \ begin {pmatrix} 1 & 7 & 3 \\ 7 & 4 & 5 \\ 3 & 5 & 6 \ end {pmatrix} $ et sa matrice de translocation. Le résultat est True, donc une matrice symétrique
>>> A=np.array([[1,7,3],[7,4,5],[3,5,6]])
>>>
>>> A
array([[1, 7, 3],
[7, 4, 5],
[3, 5, 6]])
>>>
>>> AT=A.T
>>>
>>> np.array_equal(A,AT)
True
Le produit des colonnes $ A $ et $ B $ est représenté par $ AB $ et ne peut être calculé par np.dot que si le nombre de colonnes de $ A $ et le nombre de lignes de $ B $ correspondent. La solution du produit de la matrice est différente lorsqu'elle est appliquée à partir de la droite et lorsqu'elle est appliquée à partir de la gauche.
Dans l'exemple ci-dessous, $ A = \ begin {pmatrix} 2 & 1 \\ 1 & 3 \ end {pmatrix} $ et $ B = \ begin {pmatrix} 2 & 1 \\ 1 & 2 \ end {pmatrix} Trouvez le produit de $ $ AB $.
>>> A=np.array([[2,1],[1,3]])
>>>
>>> B=np.array([[2,1],[1,2]])
>>>
>>> AB=np.dot(A,B)
>>>
>>> AB
array([[5, 4],
[5, 7]])
>>>
>>> BA=np.dot(B,A)
>>>
>>> BA
array([[5, 5],
[4, 7]])
Dans np.dot, les matrices $ A $ et $ B $ affichées sur 1 ligne et n colonnes sont considérées comme des vecteurs horizontaux à n dimensions et le produit interne des vecteurs est renvoyé. Le produit interne est la valeur scalaire obtenue en multipliant chaque élément $ n $ th et en additionnant les résultats pour tous les éléments. Si le vecteur de ligne sur le côté droit est converti en la forme d'un vecteur vertical, la valeur du produit interne est renvoyée sous forme de matrice.
Le 1 suivant est un vecteur de ligne à 4 dimensions $ a = \ begin {pmatrix} \ 0 & 0 & 0 & 0 \ end {pmatrix} $ et $ b = \ begin {pmatrix} \ 0 & 0 & 0 & 0 \ Trouvez le produit interne $ a \ cdot b $ de fin {pmatrix} $. 2 est le produit des matrices car $ b $ a été converti en vecteur colonne
>>> a=np.array([2,2,2,3])
>>>
>>> b=np.array([1,2,3,4])
>>>
>>> np.dot(a,b) ###1 Le produit interne des vecteurs a et b est renvoyé en scalaire
24
>>> np.dot(b,a) ###Comme il s'agit du produit interne des vecteurs a et b, le résultat est le même quel que soit l'ordre de multiplication.
24
>>>
>>> b_col=([[2],[2],[2],[3]]) ###2 b est une matrice à 4 colonnes unidimensionnelle
>>>
>>> np.dot(a,b_col) ###2 b est renvoyé comme une matrice à 4 colonnes unidimensionnelle
array([24])
>>>
Une matrice dans laquelle la matrice unitaire $ E $ est obtenue indépendamment du fait que la matrice carrée A soit multipliée à partir de la droite ou de la gauche. Lorsque la matrice inverse est indiquée par $ A ^ {-1} $ pour la matrice $ A $ $ AA ^ {-1} = A ^ {-1} A = E $ tient
Par exemple, créez une matrice 2 par 2 $ A = \ begin {pmatrix} 2 & 3 \\ 2 & 4 \ end {pmatrix} $ et trouvez sa matrice inverse $ A ^ {-1} $.
>>> A=np.array([[2,3],[2,4]])
>>>
>>> AI=np.linalg.inv(A)
>>>
>>> AI
array([[ 2. , -1.5],
[-1. , 1. ]])
Une matrice carrée avec une matrice inverse. Toutes les matrices n'ont pas de matrice inverse.
Dans l'exemple ci-dessous, $ AA ^ {-1} = A ^ {-1} A = E $ peut être confirmé, donc $ A $ et $ AI $ sont des matrices régulières.
>>> A=np.array([[1,1],[2,4]])
>>>
>>> AI=np.linalg.inv(A)
>>>
>>> np.dot(A,AI)
array([[1., 0.],
[0., 1.]])
>>>
>>> np.dot(AI,A)
array([[1., 0.],
[0., 1.]])
Recommended Posts