Линейная алгебра NumPy

　 　 пример NumPy линейной алгебры

numpy.dot()

numpy.dot() для двух одномерных массивов вычисляет сумму произведений элементов, соответствующих по индексу (математически называется внутренним произведением); для двумерных массивов вычисляет матричное произведение; для многомерных массивов его общая формула расчета следующая, то есть каждый элемент результатного массива: сумма произведений всех элементов последнего измерения массива a с соответствующими элементами второго измерения массива b: dot(a, b)[i,j,k,m] = сумма (a[i,j,:] * b[k,:,m]).

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

Описание параметров:

a : ndarray массив b : ndarray массив out : ndarray, опционально, используется для сохранения результата вычисления dot()

　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))

Результат вывода:

　[37 40]　
　[85 92]]

Формула вычисления:

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

numpy.vdot()

Функция numpy.vdot() возвращает точный продукт двух векторов. Если первый параметр является комплексным числом, то используется его комплексное conjugатное. Если параметры являются многомерными массивами, они расширяются.

　import numpy.matlib
　import numpy as np
　a = np.array([[1,2],[3,4]])　
　b = np.array([[11,12],[13,14]])　
　　
　# vdot расширяет массив для вычисления внутреннего продукта
　print(np.vdot(a, b))

Результат вывода:

　130

Формула вычисления:

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

numpy.inner()

Функция numpy.inner() возвращает векторный внутренний продукт одномерного массива. Для более высоких размерностей она возвращает произведение суммы на последней оси.

　import numpy.matlib
　print(np.inner(np.array([1,2,3]), np.array([0,1,0])))
　# Эквивалентно 1*0+2*1+3*0

Результат вывода:

　　　2

　import numpy as np　
　a　=　np.array([[1,2],　[3,4]])　
　　
　print('Массив a:')
　print(a)
　b = np.array([[11, 12], [13, 14]])　
　　
　print('Массив b:')
　print(b)
　　
　print('Внутренний продукт:')
　print(np.inner(a, b))

Результат вывода:

　Массив 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]]

Формула вычисления внутреннего продукта:

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

numpy.matmul

Функция numpy.matmul возвращает матричное произведение двух массивов. Хотя она возвращает нормальное произведение двумерных массивов, если размерность одного из параметров больше 2, то его рассматривают как существующую в последних двух индексах матрицу, и выполняют соответствующее расширение.

С другой стороны, если один из параметров является одномерным массивом, то его повышают до матрицы, добавив 1 к его размерности, и после умножения удаляют.

Для двумерного массива, это именно матричное умножение:

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

Результат вывода:

　　　[[4 1]　
　　[2 2]]

Двумерные и одномерные вычисления:

　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))

Результат вывода:

　[1 2]　
　[1 2]

Вектор с размерностью больше двух:

　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))

Результат вывода:

　　　[[[　2　3]]
　　　[　6　11]]
　　[[10　19]]
　　　[14　27]]]

numpy.linalg.det()

Функция numpy.linalg.det() вычисляет行列ет ввести матрицу.

Детерминант в линейной алгебре — это очень полезное значение. Он вычисляется по диагональным элементам квадратной матрицы. Для 2×2-ой матрицы это произведение левого верхнего и правого нижнего элементов, минус произведение других двух.

Иными словами, для матрицы [[a，b]，[c，d]],行列式的 вычисление составляет ad-bc. Большие квадратные матрицы считаются комбинацией 2×2-ых матриц.

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

Результат вывода:

-2.0

　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))

Результат вывода:

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

numpy.linalg.solve()

Функция numpy.linalg.solve() предоставляет решение линейного уравнения в виде матрицы.

Рассмотрим следующую линейную уравнение:

　x　+　y　+　z　=　6
　2y　+　5z　=　-4
　2x　+　5y　-　z　=　27

Это можно представить в виде матрицы:

Если матрица становится A, X и B, уравнение становится:

　AX　=　B
　или
　X　=　A^(-1)B

numpy.linalg.inv()

Функция numpy.linalg.inv() вычисляет обратную матрицу.

Обратная матрица (inverse matrix)：Установим, что A — это n-ый матричный элемент области чисел, если в той же области чисел существует другой n-ый матричный элемент B, который удовлетворяет условию: AB=BA=E, то B является обратной матрицей A, а A называется обратимой матрицей. Примечание: E — это единичная матрица.

　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))

Результат вывода:

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

Теперь создадим обратную матрицу матрицы A:

　import numpy as np　
　　
　a = np.array([[1,1,1],[0,2,5],[2,5,-1]])　
　　
　print('Массив a:')
　print(a)
　ainv = np.linalg.inv(a)　
　　
　print('Обратный a:')
　print(ainv)
　　
　print('Матрица b:')
　b = np.array([[6],[-4],[27]])　
　print(b)
　　
　print('Вычисление: A^(-1)B:')
　x = np.linalg.solve(a, b)　
　print(x)
　# Это решение линейной системы x = 5, y = 3, z = -2

Результат вывода:

　Массив 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.]]

　　　x = np.dot(ainv, b)