Матрично-векторные произведения через оператор @

В прошлом уроке мы разбирались с broadcasting — как NumPy согласовывает формы массивов при поэлементных операциях. Оператор @, который появляется в этом уроке, работает по совсем другой логике: он не растягивает размеры и не работает поэлементно. Он вычисляет матричное произведение, и правила совместимости у него свои.

Оператор @ и его эквивалент np.matmul

Оператор @ появился в Python 3.5 специально для матричного умножения. До него приходилось писать np.matmul(A, B) или np.dot(A, B) — @ просто делает запись короче и читаемее. Под капотом A @ B и np.matmul(A, B) — одно и то же.

Важно сразу разграничить три оператора, которые легко перепутать:

• * — поэлементное умножение: каждый элемент A умножается на соответствующий элемент B, форма массивов должна быть совместима по broadcasting.
• np.dot — для одномерных массивов ведёт себя как скалярное произведение, для двумерных — как матричное умножение, но поведение на трёхмерных и выше отличается от @.
• @ (np.matmul) — матричное умножение в строгом смысле: строки левого операнда умножаются на столбцы правого и суммируются.

Разница между * и @ хорошо видна на простом примере:

import numpy as np

A = np.array([[1, 2],
              [3, 4]])
B = np.array([[1, 0],
              [0, 1]])

print(A * B)   # поэлементно: [[1, 0], [0, 4]]
print(A @ B)   # матричное:   [[1, 2], [3, 4]]

Для единичной матрицы B разница особенно наглядна: * обнуляет недиагональные элементы, тогда как @ возвращает саму матрицу A — ровно так, как работает умножение на единичную матрицу в линейной алгебре.

Ещё одна деталь: @ не изменяет исходные массивы — результат записывается в новый объект. A и B после операции остаются прежними.

Правило согласования внутренних размеров

Прежде чем запускать @, полезно уметь предсказать результат только по форме операндов — без вычислений.

В этом уроке мы работаем с одно- и двумерными массивами, и для них правило звучит так: последняя ось левого операнда должна совпадать с предпоследней (или единственной, если правый операнд — вектор) осью правого. Именно эти два числа называют «внутренними размерами» — они как бы смотрят друг на друга в записи (m, k) @ (k, n). Если они равны, операция пройдёт. Если нет — ValueError.

Shape результата определяется «внешними» размерами — теми, что остались после сокращения внутренних:

• (m, k) @ (k, n) → (m, n) — внутренний размер k «схлопывается», остаётся (m, n)
• (m, k) @ (k,) → (m,) — вектор shape (k,) не имеет второго измерения, поэтому результат одномерный
• (n,) @ (n,) → скаляр shape () — оба измерения «схлопываются», ничего не остаётся

Чтобы проверить совместимость до запуска, достаточно выписать оба shape и мысленно поставить их рядом:

(2, 3) @ (3, 4)  →  внутренние: 3 == 3 ✓  →  результат (2, 4)
(2, 3) @ (3,)   →  внутренние: 3 == 3 ✓  →  результат (2,)
(2, 3) @ (2, 3) →  внутренние: 3 ≠ 2   ✗  →  ValueError

Обратите внимание: @ — не поэлементная операция и не broadcasting в том смысле, который мы разбирали в прошлом уроке. Правило внутренних размеров работает независимо от того, насколько похожи формы массивов в целом. Матрицы (2, 3) и (2, 3) имеют одинаковый shape — но перемножить их через @ нельзя, потому что внутренние размеры 3 и 2 не совпадают.

Примечание. Для трёхмерных и выше массивов np.matmul применяет то же правило к двум последним осям каждого операнда, а ведущие («пакетные») измерения согласуются по правилам broadcasting. Например, (5, 2, 3) @ (5, 3, 4) корректно даёт (5, 2, 4). В этом уроке мы не углубляемся в пакетное умножение — достаточно знать, что оно существует и работает согласованно с изученным правилом.

Три случая оператора @: вектор–вектор, матрица–вектор, матрица–матрица

Правило внутренних размеров абстрактно, пока не видишь, что именно происходит с числами и формой результата в каждом из трёх возможных случаев.

Случай 1: вектор @ вектор → скаляр

Когда оба операнда одномерные и имеют одинаковую длину, @ вычисляет скалярное произведение — попарно умножает элементы и суммирует. Результат — NumPy-скаляр с shape ():

import numpy as np

w = np.array([0.5, 0.3, 0.2])
x = np.array([80.0, 90.0, 70.0])

result = w @ x
print(result)        # 81.0
print(result.shape)  # ()

Здесь 0.5*80 + 0.3*90 + 0.2*70 = 40 + 27 + 14 = 81.0. Это и есть взвешенная сумма: w — веса, x — значения. Удобный случай на практике: итоговый балл экзамена, портфельная доходность, взвешенное среднее — всё это один вызов @. Обратите внимание, что result.shape возвращает (), а не (1,): NumPy-скаляр не имеет измерений вообще.

Случай 2: матрица @ вектор → вектор

Если левый операнд — матрица shape (m, k), а правый — вектор shape (k,), результат — вектор shape (m,). Каждая строка матрицы независимо перемножается на вектор и суммируется:

A = np.array([[1, 2, 3],
              [4, 5, 6]])   # shape (2, 3)
v = np.array([1.0, 0.0, -1.0])  # shape (3,)

result = A @ v
print(result)        # [-2. -2.]
print(result.shape)  # (2,)

Первая строка A: 1*1 + 2*0 + 3*(-1) = -2. Вторая: 4*1 + 5*0 + 6*(-1) = -2. Форма (2, 3) @ (3,) даёт (2,) — внутренний размер 3 исчезает, остаётся m=2.

Этот случай — рабочая лошадка линейных моделей: матрица признаков умножается на вектор весов и даёт вектор предсказаний.

Случай 3: матрица @ матрица → матрица

Два двумерных операнда shape (m, k) и (k, n) дают матрицу shape (m, n). Каждый элемент результата — скалярное произведение строки левой матрицы и столбца правой:

A = np.array([[1, 2, 3],
              [4, 5, 6]])   # shape (2, 3)
B = np.array([[1, 0],
              [0, 1],
              [1, 1]])      # shape (3, 2)

result = A @ B
print(result)
# [[ 4  5]
#  [10 11]]
print(result.shape)  # (2, 2)

Результат (2, 3) @ (3, 2) → (2, 2): внутренний размер 3 «схлопнулся», внешние 2 и 2 образовали новую матрицу.

Сводка по shape результата:

• (n,) @ (n,) → () — скаляр
• (m, k) @ (k,) → (m,) — вектор
• (m, k) @ (k, n) → (m, n) — матрица

Во всех трёх случаях работает одно и то же правило: внутренний размер сокращается, внешние формируют shape результата.

Диагностика и исправление ошибки несовпадения размеров

Рано или поздно вы напишете что-то вроде A @ B и получите стену красного текста. Разберём, как её читать.

Типичное сообщение об ошибке выглядит так:

ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0
with gufunc signature (n?,k),(k,m?)->(n?,m?)

Это не очень дружелюбно, но сообщение говорит ровно одно: внутренние размеры операндов не совпали. «Core dimension 0» правого операнда — это его первое измерение, которое должно равняться последнему измерению левого.

Воспроизведём ошибку:

import numpy as np

A = np.array([[1, 2, 3],
              [4, 5, 6]])   # shape (2, 3)
B = np.array([[1, 2, 3],
              [4, 5, 6]])   # shape (2, 3)

result = A @ B  # ValueError!

Обе матрицы имеют одинаковый shape (2, 3) — казалось бы, должно работать. Но внутренние размеры здесь 3 (последний у A) и 2 (первый у B). Они не совпадают, отсюда и ошибка.

Систематическая диагностика занимает три шага:

1. Напечатать shape обоих операндов прямо перед вызовом @:

   print(A.shape)  # (2, 3)
   print(B.shape)  # (2, 3)

2. Выписать пару «последний размер левого» и «первый размер правого» и сравнить:

   (2, 3) @ (2, 3)
         ^   ^
         3 ≠ 2  → ValueError

3. Решить, что нужно исправить: транспонировать один из операндов, изменить форму через reshape, или пересмотреть логику.

Для случая выше, если нужно перемножить A на A по правилам матричной алгебры, правильный вариант — A @ A.T или A.T @ A:

result1 = A @ A.T   # (2, 3) @ (3, 2) → (2, 2)
result2 = A.T @ A   # (3, 2) @ (2, 3) → (3, 3)

print(result1.shape)  # (2, 2)
print(result2.shape)  # (3, 3)

Оба варианта корректны с точки зрения @, но дают разные результаты — какой нужен, определяет задача.

Ещё один частый сценарий: перепутать порядок операндов. Матричное умножение не коммутативно, и A @ B в общем случае не равно B @ A. Более того, если A @ B работает, B @ A может выбросить ValueError из-за несовместимых внутренних размеров:

C = np.ones((3, 4))  # shape (3, 4)
D = np.ones((4, 2))  # shape (4, 2)

print((C @ D).shape)  # (3, 2) — OK
print((D @ C).shape)  # ValueError: 2 ≠ 3

Если ValueError возник неожиданно, первое действие — print(A.shape, B.shape). Почти всегда проблема сразу становится видна без дополнительной отладки.