numpy.matmul#
A location into which the result is stored. If provided, it must have a shape that matches the signature (n,k),(k,m)->(n,m). If not provided or None, a freshly-allocated array is returned.
For other keyword-only arguments, see the ufunc docs .
New in version 1.16: Now handles ufunc kwargs
The matrix product of the inputs. This is a scalar only when both x1, x2 are 1-d vectors.
If the last dimension of x1 is not the same size as the second-to-last dimension of x2.
If a scalar value is passed in.
Complex-conjugating dot product.
Sum products over arbitrary axes.
Einstein summation convention.
alternative matrix product with different broadcasting rules.
The behavior depends on the arguments in the following way.
- If both arguments are 2-D they are multiplied like conventional matrices.
- If either argument is N-D, N > 2, it is treated as a stack of matrices residing in the last two indexes and broadcast accordingly.
- If the first argument is 1-D, it is promoted to a matrix by prepending a 1 to its dimensions. After matrix multiplication the prepended 1 is removed.
- If the second argument is 1-D, it is promoted to a matrix by appending a 1 to its dimensions. After matrix multiplication the appended 1 is removed.
matmul differs from dot in two important ways:
- Multiplication by scalars is not allowed, use * instead.
- Stacks of matrices are broadcast together as if the matrices were elements, respecting the signature (n,k),(k,m)->(n,m) :
>>> a = np.ones([9, 5, 7, 4]) >>> c = np.ones([9, 5, 4, 3]) >>> np.dot(a, c).shape (9, 5, 7, 9, 5, 3) >>> np.matmul(a, c).shape (9, 5, 7, 3) >>> # n is 7, k is 4, m is 3
The matmul function implements the semantics of the @ operator introduced in Python 3.5 following PEP 465.
It uses an optimized BLAS library when possible (see numpy.linalg ).
For 2-D arrays it is the matrix product:
>>> a = np.array([[1, 0], . [0, 1]]) >>> b = np.array([[4, 1], . [2, 2]]) >>> np.matmul(a, b) array([[4, 1], [2, 2]])
For 2-D mixed with 1-D, the result is the usual.
>>> a = np.array([[1, 0], . [0, 1]]) >>> b = np.array([1, 2]) >>> np.matmul(a, b) array([1, 2]) >>> np.matmul(b, a) array([1, 2])
Broadcasting is conventional for stacks of arrays
>>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4)) >>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2)) >>> np.matmul(a,b).shape (2, 2, 2) >>> np.matmul(a, b)[0, 1, 1] 98 >>> sum(a[0, 1, :] * b[0 , :, 1]) 98
Vector, vector returns the scalar inner product, but neither argument is complex-conjugated:
Scalar multiplication raises an error.
>>> np.matmul([1,2], 3) Traceback (most recent call last): . ValueError: matmul: Input operand 1 does not have enough dimensions .
The @ operator can be used as a shorthand for np.matmul on ndarrays.
>>> x1 = np.array([2j, 3j]) >>> x2 = np.array([2j, 3j]) >>> x1 @ x2 (-13+0j)
Произведение матриц и векторов, элементы линейной алгебры
Пришло время познакомиться с одной из фундаментальных возможностей пакета NumPy–матричных и векторных вычислений. На одном из прошлых занятий мы с вами уже видели, как можно поэлементно умножать один вектор на другой или одну матрицу на другую:
a = np.arange(1, 10).reshape(3, 3) b = np.arange(10, 19).reshape(3, 3) a*b
В консоли увидим результат:
array([[ 10, 22, 36],
[ 52, 70, 90],
[112, 136, 162]])
Матричное умножение
Но если нам нужно выполнить именно матричное умножение, то есть, строки одной матрицы умножать на столбцы другой и результаты складывать:
то для этого следует использовать специальные функции и операторы. Начнем с функций. Итак, чтобы перемножить две матрицы a иbпо всем правилам математики, запишем следующую команду:
Эта функция возвращает новую матрицу (двумерный массив) с результатом умножения:
array([[ 84, 90, 96],
[201, 216, 231],
[318, 342, 366]])
Тот же результат можно получить и с помощью функции:
Считается, что этот вариант предпочтительнее использовать при умножении матриц.
Векторное умножение
Аналогичные операции можно выполнять и с векторами. Математически, если у нас имеются два вектора:
то их умножение можно реализовать в двух видах:
Первое умножение реализуется либо через функцию:
a = np.arange(1, 10) b = np.ones(9) np.dot(a, b) # значение 45
Либо, более предпочтительной функцией для внутреннего умножения векторов:
Второй вариант умножения (внешнее умножение векторов) реализуется с помощью функции:
получим результат в виде следующей матрицы:
array([[1., 1., 1., 1., 1., 1., 1., 1., 1.],
[2., 2., 2., 2., 2., 2., 2., 2., 2.],
[3., 3., 3., 3., 3., 3., 3., 3., 3.],
[4., 4., 4., 4., 4., 4., 4., 4., 4.],
[5., 5., 5., 5., 5., 5., 5., 5., 5.],
[6., 6., 6., 6., 6., 6., 6., 6., 6.],
[7., 7., 7., 7., 7., 7., 7., 7., 7.],
[8., 8., 8., 8., 8., 8., 8., 8., 8.],
[9., 9., 9., 9., 9., 9., 9., 9., 9.]])
Операция умножения матриц и векторов используется довольно часто, поэтому в пакете NumPy имеется весьма полезный перегруженный оператор, заменяющий функцию matmul:
или, с использованием матриц:
a.resize(3, 3) b.resize(3, 3) a @ b # аналог np.matmul(a, b)
Умножение вектора на матрицу
Наконец, рассмотрим умножение вектора на матрицу. Это также можно записать двумя способами:
Для реализации первого способа, зададим одномерный вектор и двумерную матрицу:
a = np.array([1,2,3]) b = np.arange(4,10).reshape(3,2) # матрица 3x2
И, затем, воспользуемся уже знакомой нам функцией dot:
При такой записи, когда одномерный массив записан первым аргументом, а матрица – вторым, получаем умножение вектора-строки на матрицу, то есть, первый способ.
Для реализации второго способа аргументы нужно поменять местами: сначала указать матрицу, а затем, вектор. Но, если мы сейчас это сделаем с нашими массивами, то получим ошибку:
np.dot(b, a) # несогласованность размеров
Дело в том, что массив a должен представлять вектор длиной два элемента, так как матрица b имеет размер в 3 строки и 2 столбца:
Определим массивa в два элемента и умножим на матрицу b:
a = np.array([1, 2]) np.dot(b, a) # array([14, 20, 26])
Получаем вектор-строку (одномерный массив) как результат умножения. Обратите внимание, по правилам математики вектор aдолжен быть вектором-столбцом, то есть, быть представленным в виде:
a.shape = -1, 1 # вектор-столбец 2x1
Но мы использовали вектор-строку. В NumPyтак тоже можно делать и это не приведет к ошибке. Результат будет именно умножение матрицы как бы на вектор-столбец. Ну а если использовать вектор-столбец, то и на выходе получим вектор-столбец:
np.dot(b, a) # вектор-столбец 3x1
Этого же результат можно достичь, используя оператор @ (перегрузка функции matmul):
Результат будет тем же. Вот так в NumPyвыполняется умножение матриц, векторов и вектора на матрицу.
Элементы линейной алгебры
Из высшей математики хорошо известно, что матрицы можно использовать для решения систем линейных уравнений. Для этого в NumPyсуществует модуль linalg. Давайте рассмотрим некоторые из его функций.
Предположим, имеется квадратная матрица 3×3:
a = np.array([(1, 2, 3), (1, 4, 9), (1, 8, 27)])
Первым делом вычислим ранг этой матрицы, чтобы быть уверенным, что она состоит из линейно независимых строк и столбцов:
np.linalg.matrix_rank(a) # рангравен 3
Если ранг матрицы совпадает с ее размерностью, значит, она способна описывать систему из трех независимых линейных уравнений. В нашем случае, система уравнений будет иметь вид:
Здесь — некие числа линейного уравнения. Например, возьмем их равными:
Тогда корни уравнения можно вычислить с помощью функции solve:
np.linalg.solve(a, y) # array([-5. , 10. , -1.66666667])
Другой способ решения этой же системы линейных уравнений возможен через вычисление обратной матрицы. Изначально, уравнение можно записать в векторно-матричном виде:
Откуда получаем решения :
На уровне пакета NumPy это делается так:
invA = np.linalg.inv(a) # вычисление обратной матрицы invA @ y # вычисление корней
Умножение матриц NumPy: начните за 5 минут
Без рубрики
NumPy — популярная библиотека Python, которая предлагает ряд мощных математических функций. Библиотека широко используется в количественных областях, таких как наука о данных, машинное обучение и глубокое обучение. Мы можем использовать NumPy для выполнения сложных математических вычислений, таких как умножение матриц.
Умножение матриц может помочь нам быстро приблизиться к очень сложным вычислениям. Он может помочь нам в теории сетей, линейных системах уравнений, моделировании населения и многом другом. В этом руководстве мы рассмотрим некоторые основные вычисления с умножением матриц NumPy.
Что такое NumPy?
NumPy — это библиотека Python с открытым исходным кодом, которую мы можем использовать для выполнения высокоуровневых математических операций с массивами, матрицами, линейной алгеброй, анализом Фурье и т. Д. Библиотека NumPy очень популярна в научных вычислениях, науках о данных и машинном обучении. NumPy совместим с популярными библиотеками данных, такими как pandas, matplotlib и Scikit-learn. Это намного быстрее, чем списки Python, потому что он объединяет более быстрые коды, такие как C и C ++, в Python. Он также разбивает наши задачи на несколько частей и обрабатывает каждую часть одновременно.
Установка и импорт NumPy
Прежде чем мы начнем, убедитесь, что у нас установлен NumPy. Если у вас уже есть Python, вы можете установить NumPy с помощью одной из следующих команд: