Умножение массивов NumPy | Научные вычисления в Python

Введение

NumPy - это мощная библиотека для научных вычислений в Python. Одной из наиболее важных особенностей NumPy является ее способность эффективно выполнять различные виды умножения массивов.

В этом руководстве мы рассмотрим разные операции умножения, доступные в NumPy, включая numpy.multiply, numpy.dot, numpy.matmul, операторы * и @.

Вступление

Прежде чем мы углубимся в различные операции умножения в NumPy, давайте сначала откроем оболочку Python, введя следующую команду в терминале.

python3

Затем импортируем библиотеку и создадим несколько примерных массивов, которые мы можем использовать для демонстрации.

import numpy as np

## Создание примерных массивов
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

Мы создали два массива A и B, каждый из которых имеет две строки и два столбца. Теперь давайте исследуем различные операции умножения, доступные в NumPy.

numpy.multiply

Функция numpy.multiply выполняет поэлементное умножение между двумя массивами. Два массива должны иметь одинаковую форму. Результирующий массив будет иметь ту же форму, что и входные массивы.

C = np.multiply(A, B)

print(C)
## Output:
## array([[ 5, 12],
##       [21, 32]])

В этом примере каждый элемент в A умножается на соответствующий элемент в B, что приводит к поэлементному умножению двух массивов.

numpy.dot

Функция numpy.dot выполняет матричное умножение между двумя массивами. Первый массив должен иметь такое же количество столбцов, как у второго массива строк. Результирующий массив будет иметь такое же количество строк, как у первого массива, и такое же количество столбцов, как у второго массива.

C = np.dot(A, B)

print(C)
## Output:
## array([[19, 22],
##        [43, 50]])

В этом примере мы выполнили матричное умножение между массивами A и B. Результирующий массив C имеет две строки и два столбца, как и ожидалось.

numpy.matmul

Функция numpy.matmul также выполняет матричное умножение между двумя массивами, но имеет несколько разных правил для обработки многомерных массивов. Два массива должны иметь одинаковую форму, за исключением последних двух измерений, которые должны совпадать. Если любой из массивов 1-D, то он преобразуется в матрицу путём добавления 1 к его форме.

C = np.matmul(A, B)

print(C)
## Output:
## array([[19, 22],
##        [43, 50]])

В этом примере мы получаем тот же результат, что и с numpy.dot. Это происходит потому, что наши массивы A и B имеют одинаковую форму, поэтому numpy.matmul ведёт себя так же, как numpy.dot.

И есть ещё один пример:

## определить два 3-D массива
a = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
b = np.array([[[9, 10], [11, 12]], [[13, 14], [15, 16]]])

c = np.matmul(a, b)
d = np.dot(a, b)

print(c)
## Output:
## array([[[ 31,  34],
##        [ 71,  78]],
##        [[155, 166],
##        [211, 226]]])

print(d)
## Output:
## array([[[[ 31,  34],
##         [ 43,  46]],
##        [[ 71,  78],
##         [ 99, 106]]],
##       [[[111, 122],
##         [155, 166]],
##        [[151, 166],
##         [211, 226]]]])

В этом примере numpy.matmul выполняет операцию пакетного матричного умножения.

Поскольку и a, и b - это 3-D массивы, то выход numpy.dot будет иметь размерность $(2,2,2,2)$ . Первые два измерения соответствуют двум пакетам матриц $2\times2$ в a и b. Следующие два измерения соответствуют скалярному произведению каждой пары матриц $2\times2$ в пакетах:

## первый результат 2 × 2
dot(a[0], b[0]) =
dot([[1, 2],
 [3, 4]],
 [[9, 10],
 [11, 12]]
= [[1*9 + 2*11, 1*10 + 2*12],
   [3*9 + 4*11, 3*10 + 4*12]]
= [[31, 34],
   [43, 46]]

Оператор *

Оператор * также выполняет поэлементное умножение между двумя массивами, но ведёт себя немного по-разному, чем numpy.multiply. Если два массива имеют одинаковую форму, то оператор * будет выполнять поэлементное умножение, точно так же, как numpy.multiply. Однако, если один из массивов является скалярным значением, то оператор * будет выполнять скалярное умножение на каждый элемент другого массива.

C = A * B
D = A * 2

print(C)
## Output:
#array([[ 5, 12],
##       [21, 32]])

print(D)
## Output:
## array([[2, 4],
##       [6, 8]])

В первом примере мы получаем тот же результат, что и с numpy.multiply. Во втором примере мы выполняем скалярное умножение на каждый элемент массива A.

Оператор @

Оператор @ выполняет матричное умножение, точно так же, как numpy.dot и numpy.matmul. Он был введён в Python 3.5 в качестве сокращения для numpy.matmul.

C = A @ B

print(C)
## Output:
## array([[19, 22],
##       [43, 50]])

В этом примере мы используем оператор @ для выполнения матричного умножения между массивами A и B. Результирующий массив C имеет две строки и два столбца, точно так же, как и при использовании numpy.dot и numpy.matmul.

Резюме

В этом уроке мы изучили различные операции умножения в NumPy. Каждая из этих операций имеет свои собственные правила и области применения, поэтому важно выбрать правильную для вашей конкретной задачи. Освоив эти операции, вы сможете эффективно выполнять умножение массивов и матриц в Python с использованием NumPy.

Эффективные операции умножения массивов NumPy