Матрицы и матричное умножение

Зачем это нужно

Если посмотреть, на что уходит время при обучении и работе трансформера, почти всё окажется умножением матриц. Проекции запросов, ключей и значений во внимании (формулу attention вы читали в уроке 1.0.3), оба слоя FFNполносвязный блок (FFN)EN feed-forward network (FFN) (feed-forward network — блок из двух слоёв нейронов, который стоит в каждом слое трансформера), выходной слой со словарём в сотню тысяч токенов — это матричные умножения. Видеокарты потому и стали главным железом ИИ, что умеют делать их невероятно быстро.

В прошлом уроке мы научились работать с векторами. Теперь научимся их преобразовывать. Матрица — это способ одним объектом записать преобразование «вектор → вектор». А линейный слойлинейный (полносвязный) слойEN linear layer (fully connected layer)y = xWᵀ + b. В PyTorch nn.Linear(in, out) хранит weight формы (out, in) — частый источник путаницы. нейросети — это ровно одна матрица плюс сдвиг. В конце урока вы напишете матричное умножение руками и поймёте, что именно делает nn.Linear в PyTorch.

Матрица — таблица чисел

МатрицаматрицаEN matrixПрямоугольная таблица чисел размера m×n. Задаёт линейное преобразование из n-мерного пространства в m-мерное. размера $m \times n$ — это прямоугольная таблица из $m$ строк и $n$ столбцов. Размер читается «эм на эн», сначала строки:

$$A = \begin{pmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{pmatrix} \in \mathbb{R}^{2 \times 3}$$

Элемент в строке $i$ и столбце $j$ обозначают $a_{ij}$: здесь $a_{23} = 6$. В NumPy форма матрицы — A.shape == (2, 3), а тот же элемент — A[1, 2], потому что в Python счёт идёт с нуля. Эта разница в индексах — классический источник ошибок при переводе формул в код.

Матрицы в LLM огромные. Таблица эмбеддингов DeepSeek-V3 — матрица $129\,280 \times 7168$: по строке на каждый токен словаря, всего около 927 млн чисел. Каждый слой содержит ещё несколько матриц весов.

Матрица, умноженная на вектор: два взгляда

Возьмём $A = \begin{pmatrix} 2 & 0 \\ 1 & 3 \end{pmatrix}$ и $\mathbf{x} = (1, 2)$. Произведение $A\mathbf{x}$ можно понимать двумя способами, и оба нужны.

Взгляд 1: строки на вектор. Каждая координата результата — скалярное произведение строки матрицы на $\mathbf{x}$:

$$A\mathbf{x} = \begin{pmatrix} 2 \cdot 1 + 0 \cdot 2 \\ 1 \cdot 1 + 3 \cdot 2 \end{pmatrix} = \begin{pmatrix} 2 \\ 7 \end{pmatrix}$$

Так удобно считать. И так удобно думать о нейронах: каждая строка — веса одного нейрона, а $m$ строк — это $m$ нейронов, которые смотрят на один и тот же вход.

Взгляд 2: комбинация столбцов. Результат — это линейная комбинация (урок 1.1.1) столбцов матрицы с коэффициентами из $\mathbf{x}$: первый столбец берём $x_1 = 1$ раз, второй — $x_2 = 2$ раза и складываем:

$$A\mathbf{x} = 1 \cdot \begin{pmatrix} 2 \\ 1 \end{pmatrix} + 2 \cdot \begin{pmatrix} 0 \\ 3 \end{pmatrix} = \begin{pmatrix} 2 \\ 7 \end{pmatrix}$$

Так удобно понимать, что делает матрица. Об этом следующий раздел.

Формы: матрица $(m \times n)$ принимает вектор длины $n$ и возвращает вектор длины $m$. Значит, матрица — это функция $\mathbb{R}^n \to \mathbb{R}^m$. Если длина вектора не равна числу столбцов, умножать нельзя: NumPy ответит ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0 … (size 2 is different from 3). Сообщение длинное, но главное в нём — в конце: какие размеры не совпали.

Матрица — это преобразование пространства

Возьмём базисные векторы — единичные стрелки вдоль осей $\mathbf{e}_1 = (1, 0)$ и $\mathbf{e}_2 = (0, 1)$ — и умножим на них матрицу. По «взгляду 2» $A\mathbf{e}_1$ — это просто первый столбец $A$, а $A\mathbf{e}_2$ — второй. Отсюда главная идея урока:

Столбцы матрицы — это то, куда она переводит базисные векторы. Зная, куда попали $\mathbf{e}_1$ и $\mathbf{e}_2$, мы знаем, куда попадёт любой вектор $\mathbf{x} = x_1 \mathbf{e}_1 + x_2 \mathbf{e}_2$.

Такие преобразования называют линейнымилинейное преобразованиеEN linear map (linear transformation)Функция f, для которой f(a + b) = f(a) + f(b) и f(c·a) = c·f(a). Каждое такое преобразование — умножение на матрицу.. Они уважают сложение и умножение на число: $A(\mathbf{a} + \mathbf{b}) = A\mathbf{a} + A\mathbf{b}$ и $A(c\,\mathbf{a}) = c\,A\mathbf{a}$. Геометрически это значит, что прямые остаются прямыми (или схлопываются в точку, как при проекции ниже), параллельные — параллельными, а начало координат остаётся на месте.

Пунктир — единичный квадрат до преобразования, зелёная фигура — после. Красная и жёлтая стрелки — куда попали базисные векторы e₁ = (1, 0) и e₂ = (0, 1); это и есть столбцы матрицы.

Преобразование	Матрица	Что происходит
Растяжение	$\begin{pmatrix} 2 & 0 \\ 0 & 0.5 \end{pmatrix}$	по $x$ вдвое длиннее, по $y$ вдвое короче
Поворот на 90°	$\begin{pmatrix} 0 & -1 \\ 1 & 0 \end{pmatrix}$	всё вращается против часовой стрелки
Скос (shear)	$\begin{pmatrix} 1 & 1 \\ 0 & 1 \end{pmatrix}$	квадрат «съезжает» вбок и становится параллелограммом
Проекция	$\begin{pmatrix} 1 & 0 \\ 0 & 0 \end{pmatrix}$	всё сплющивается на ось $x$, информация об $y$ теряется
Ничего не делать	$\begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix}$	единичная матрицаединичная матрицаEN identity matrixКвадратная матрица I с единицами на диагонали и нулями вне её; Ix = x. В NumPy — np.eye(n). $I$: $I\mathbf{x} = \mathbf{x}$

Обратите внимание на проекцию: она «схлопывает» плоскость в линию. Такие матрицы теряют информацию, и в следующем уроке мы научимся это измерять числом — рангом.

Неквадратные матрицы меняют размерность. Матрица $3 \times 2$ переносит плоскость в трёхмерное пространство, матрица $2 \times 3$ сплющивает трёхмерное пространство в плоскость. В нейросетях это обычное дело: в FFN-блоке GPT-2 вектор размерности 768 сначала «раздувают» до 3072, а потом сжимают обратно до 768.

Умножение матриц — композиция преобразований

Что будет, если применить к вектору сначала преобразование $B$, а потом $A$? Получится $A(B\mathbf{x})$. Оказывается, это тоже линейное преобразование, и его матрицу называют произведением $AB$:

$$(AB)\,\mathbf{x} = A\,(B\mathbf{x})$$

Читать произведение нужно справа налево: в $AB$ сначала действует $B$, потом $A$ — как в композиции функций $f(g(x))$ из урока 1.0.1.

Как считать

Матричное умножениематричное умножениеEN matrix multiplication (matmul)(m×n)·(n×k) → (m×k), элемент cᵢⱼ = Σₜ aᵢₜbₜⱼ. Соответствует композиции преобразований. Стоит ≈ 2·m·n·k операций. $C = AB$ определено, когда число столбцов $A$ равно числу строк $B$. Элемент $c_{ij}$ — скалярное произведение $i$-й строки $A$ на $j$-й столбец $B$:

$$c_{ij} = \sum_{t=1}^{n} a_{it}\, b_{tj}$$

Пример:

$$\begin{pmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{pmatrix} \begin{pmatrix} 7 & 8 \\ 9 & 10 \\ 11 & 12 \end{pmatrix} = \begin{pmatrix} 58 & 64 \\ 139 & 154 \end{pmatrix}$$

Левый верхний элемент: первая строка $(1, 2, 3)$ на первый столбец $(7, 9, 11)$ — это $7 + 18 + 33 = 58$. Остальные три — так же.

Правило форм: $(m \times n) \cdot (n \times k) \to (m \times k)$. Внутренние размеры совпадают и «сокращаются», внешние остаются. Проверяйте формы раньше, чем значения, — это сэкономит часы отладки:

Что умножаем	Формы	Результат
Батч эмбеддингов на веса слоя	$(32 \times 768) \cdot (768 \times 3072)$	$(32 \times 3072)$
Матрица на вектор-столбец	$(m \times n) \cdot (n \times 1)$	$(m \times 1)$
Строка на столбец	$(1 \times n) \cdot (n \times 1)$	$(1 \times 1)$ — скалярное произведение
Столбец на строку	$(m \times 1) \cdot (1 \times n)$	$(m \times n)$ — внешнее произведение

Свойства, которые нужно знать

• Порядок важен: в общем случае $AB \ne BA$. Возьмём поворот на 90° $R$ и растяжение по оси $x$ $S = \begin{pmatrix} 2 & 0 \\ 0 & 1 \end{pmatrix}$. Вектор $\mathbf{e}_1 = (1, 0)$ после $RS$ (сначала растянуть, потом повернуть) превращается в $(0, 2)$, а после $SR$ (сначала повернуть, потом растянуть) — в $(0, 1)$. Растяжение по $x$ уже ничего не делает с вектором, который смотрит вверх.
• Скобки можно переставлять: $(AB)C = A(BC)$. Это свойство называют ассоциативностью. Результат одинаковый, а стоимость — нет (см. ниже).
• Единичная матрица — «единица» умножения: $AI = IA = A$.

import numpy as np

R = np.array([[0, -1], [1, 0]])   # поворот на 90°
S = np.array([[2, 0], [0, 1]])    # растяжение по x
e1 = np.array([1, 0])
print((R @ S) @ e1)   # [0 2] — сначала S, потом R
print((S @ R) @ e1)   # [0 1] — сначала R, потом S

Сколько это стоит

Каждый из $m \cdot k$ элементов результата — скалярное произведение длины $n$, то есть около $2n$ операций. Итого умножение $(m \times n)(n \times k)$ стоит примерно $2mnk$ операций с плавающей точкой (FLOPs). Пример: один слой FFN GPT-2 ($768 \to 3072$) на 1024 токенах — это $2 \cdot 1024 \cdot 768 \cdot 3072 \approx 4.8$ млрд операций.

Из ассоциативности следует важный инженерный трюк. Пусть $A$ и $B$ — матрицы $4096 \times 4096$, а $\mathbf{x}$ — вектор.

• $(AB)\mathbf{x}$: сначала перемножаем матрицы ($2 \cdot 4096^3 \approx 137$ млрд операций), потом умножаем на вектор.
• $A(B\mathbf{x})$: два умножения матрицы на вектор, $2 \cdot 2 \cdot 4096^2 \approx 67$ млн операций.

Ответ одинаковый, а второй путь в 2048 раз дешевле. На перестановке скобок построено «поглощение матриц» в механизме MLA от DeepSeek (урок 5.2.2): там тоже выбирают, в каком порядке перемножать, чтобы не делать лишней работы.

И ещё о скорости. Наивный тройной цикл на чистом Python перемножает две матрицы $200 \times 200$ примерно за 1 секунду, а NumPy на одном ядре процессора — примерно за 1 миллисекунду, то есть в тысячу с лишним раз быстрее (замер на машине автора; у вас числа будут другими, но порядок тот же). NumPy вызывает библиотеку BLAS, где умножение матриц оптимизировано под кэши и векторные инструкции процессора. Поэтому в практике ниже вы напишете умножение руками один раз, чтобы понять, а дальше всегда будете использовать @.

Транспонирование

ТранспонированиетранспонированиеEN transposeСтроки становятся столбцами — Aᵀ. Полезное правило — (AB)ᵀ = BᵀAᵀ. В NumPy и PyTorch — A.T. меняет строки и столбцы местами: $(A^\top)_{ij} = a_{ji}$, форма $(m \times n)$ становится $(n \times m)$. В коде — A.T.

$$\begin{pmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{pmatrix}^{\!\top} = \begin{pmatrix} 1 & 4 \\ 2 & 5 \\ 3 & 6 \end{pmatrix}$$

Полезное правило: $(AB)^\top = B^\top A^\top$ — при транспонировании произведения множители меняются местами. Проверьте на примере выше: $(AB)^\top = \begin{pmatrix} 58 & 139 \\ 64 & 154 \end{pmatrix}$, и B.T @ A.T даёт то же самое.

В статьях векторы обычно считают столбцами (матрицами $n \times 1$). Тогда скалярное произведение записывают как $\mathbf{x}^\top \mathbf{y}$ — строка на столбец, получается $1 \times 1$. А столбец на строку, $\mathbf{x}\mathbf{y}^\top$, даёт целую матрицу — внешнее произведениевнешнее произведениеEN outer productСтолбец на строку — u vᵀ, матрица ранга 1. В китайских текстах «внешним произведением» иногда называют векторное произведение (cross product), смотрите по контексту.:

$$\begin{pmatrix} 1 \\ 2 \end{pmatrix} \begin{pmatrix} 3 & 4 & 5 \end{pmatrix} = \begin{pmatrix} 3 & 4 & 5 \\ 6 & 8 & 10 \end{pmatrix}$$

Все строки этой матрицы пропорциональны друг другу. Такие матрицы «ранга 1» — главные герои следующего урока и формулы градиента в уроке 1.2.3.

Линейный слой нейросети

Теперь соберём всё вместе. Слой из $m$ нейронов, каждый со своими весами (строка матрицы $W$) и своим смещениемсмещение (bias)EN biasСвободный член b в y = Wx + b. Не путать с «предвзятостью» модели (bias в смысле fairness) и со смещением в bias–variance. $b_i$ (его ещё называют сдвигом — то самое $b$ из $y = kx + b$, урок 1.0.1), считает

$$\mathbf{y} = W\mathbf{x} + \mathbf{b}, \qquad W \in \mathbb{R}^{m \times n}, \; \mathbf{x} \in \mathbb{R}^{n}, \; \mathbf{y}, \mathbf{b} \in \mathbb{R}^{m}$$

Это линейный (полносвязный) слой. Числа: пусть $W = \begin{pmatrix} 1 & 0 \\ 0 & 1 \\ 1 & 1 \end{pmatrix}$ (3 нейрона, у каждого 2 входа), $\mathbf{b} = (0, 0, 10)$ и $\mathbf{x} = (1, 2)$. Строки $W$ на $\mathbf{x}$ дают $(1, 2, 3)$, плюс сдвиг — $\mathbf{y} = (1, 2, 13)$. Этот же пример печатает заготовка задания в конце урока.

В коде векторы обычно лежат строками матрицы. Так удобно обрабатывать сразу батч — пачку из $B$ примеров, которые модель считает одновременно (на видеокарте это почти так же быстро, как один пример). Батч $X$ формы $(B, n)$ превращается в $Y$ формы $(B, m)$ по формуле

$$Y = X W^\top + \mathbf{b}$$

Читаем: каждая строка $X$ (один пример) умножается на $W^\top$ — это то же «строки $W$ на вектор», только для всех примеров сразу, — и к каждой строке результата прибавляется $\mathbf{b}$. Сдвиг прибавляется к каждой строке благодаря broadcasting (урок 0.3.2). На NumPy:

import numpy as np

W = np.array([[1.0, 0.0], [0.0, 1.0], [1.0, 1.0]])   # (out, in) = (3, 2): строка — веса одного нейрона
b = np.array([0.0, 0.0, 10.0])                       # по одному сдвигу на нейрон
X = np.array([[1.0, 2.0],                            # батч из двух примеров, форма (2, 2)
              [3.0, -1.0]])
Y = X @ W.T + b                                      # (2, 2) @ (2, 3) → (2, 3), затем + b к каждой строке
print(Y)

[[ 1.  2. 13.]
 [ 3. -1. 12.]]

Первая встреча с PyTorch

Дальше в курсе будут встречаться блоки кода на PyTorch — главной библиотеке для нейросетей. Вы установили её в уроке 0.1.2, а систематически изучать будем на ступени 3. Пока достаточно трёх соответствий с NumPy: тензортензорEN tensorВ ML — просто многомерный массив чисел. torch.Tensor устроен как np.ndarray, но умеет работать на GPU и считать градиенты. (torch.tensor, torch.randn) — это почти то же, что массив NumPy; torch.manual_seed(0) — то же, что np.random.default_rng(0), фиксирует случайность (урок 0.3.3); torch.allclose(a, b) — как np.allclose: «равны ли массивы с точностью до округления». На ступени 1 такие блоки нужны, чтобы увидеть, что формулы урока — ровно то, что делает настоящая библиотека. Запускайте их и сверяйте вывод, но не пугайтесь незнакомых имён: каждое объяснено в комментарии.

Так устроен nn.Linear в PyTorch — тот же расчёт, только веса создаются случайными и хранятся внутри слоя:

import torch

torch.manual_seed(0)                     # фиксируем случайность, как seed в NumPy
layer = torch.nn.Linear(768, 3072)       # слой 768 → 3072, как в FFN GPT-2; веса — случайные числа
print(layer.weight.shape)                # torch.Size([3072, 768]) — (out, in)!
print(layer.bias.shape)                  # torch.Size([3072])
# parameters() перебирает все обучаемые массивы слоя (weight и bias), numel() — число элементов в массиве
print(sum(p.numel() for p in layer.parameters()))   # 2362368 = 768·3072 + 3072

x = torch.randn(32, 768)                 # батч из 32 случайных векторов (как rng.standard_normal)
y = layer(x)                             # вызов слоя как функции: считает x @ W.T + b
print(y.shape)                           # torch.Size([32, 3072])
print(torch.allclose(y, x @ layer.weight.T + layer.bias, atol=1e-6))   # True — та же формула

X = torch.randn(4, 10, 768)              # (батч, токены, признаки)
print(layer(X).shape)                    # torch.Size([4, 10, 3072]) — слой действует на последнюю ось

Ловушка: форма весов nn.Linear

nn.Linear(in_features, out_features) хранит веса в форме (out, in), а не (in, out). Поэтому в формуле стоит W.T. Если вы переносите веса из NumPy-реализации, где матрица хранилась как (in, out), их нужно транспонировать. При квадратной матрице ошибки не будет, просто модель станет считать чепуху. Это ещё одна запись для тетради ошибок.

Два линейных слоя — это один слой

В уроке 1.0.1 мы видели, что $2(3x + 1) + 5 = 6x + 7$: композиция прямых — снова прямая. Матричная версия того же факта:

$$W_2 (W_1 \mathbf{x} + \mathbf{b}_1) + \mathbf{b}_2 = \underbrace{(W_2 W_1)}_{W}\, \mathbf{x} + \underbrace{(W_2 \mathbf{b}_1 + \mathbf{b}_2)}_{\mathbf{b}}$$

Сколько линейных слоёв ни ставь подряд, получится одна матрица $W$ и один сдвиг $\mathbf{b}$. Проверим:

torch.manual_seed(0)
l1 = torch.nn.Linear(4, 8)
l2 = torch.nn.Linear(8, 3)
W = l2.weight @ l1.weight                 # (3, 8) @ (8, 4) → (3, 4)
b = l2.weight @ l1.bias + l2.bias         # (3,)
x = torch.randn(5, 4)
print(torch.allclose(l2(l1(x)), x @ W.T + b, atol=1e-6))   # True

Поэтому между линейными слоями всегда стоит нелинейность — ReLU, GELU или SiLU (урок 3.1.1). А сами линейные слои делают всю «тяжёлую» работу: именно в их матрицах хранится почти всё, что знает модель.

flowchart LR
X["x, 768 чисел"] --> L1["Linear 768 → 3072<br/>W₁: 3072×768"] --> G["GELU"] --> L2["Linear 3072 → 768<br/>W₂: 768×3072"] --> Y["y, 768 чисел"]

FFN-блок GPT-2: две матрицы и нелинейность между ними

Практика

Реализуйте shape, transpose, matmul и linear на чистом Python. Тесты сверят ваш ответ с NumPy на случайных неквадратных матрицах — в них перепутанные индексы сразу дают ошибку.

Матричное умножение руками и линейный слойnumpy · нужен интернет6 тестов

# Матрица — список строк: [[1, 2, 3], [4, 5, 6]] — это 2 строки и 3 столбца.


def shape(A):
    """Форма матрицы: кортеж (число строк, число столбцов).

    Пример: shape([[1, 2, 3], [4, 5, 6]]) → (2, 3).
    """
    # TODO: строк — len(A), столбцов — длина первой строки len(A[0])
    ...


def transpose(A):
    """Транспонирование: строки становятся столбцами. Форма (m, n) → (n, m).

    Пример: transpose([[1, 2, 3], [4, 5, 6]]) → [[1, 4], [2, 5], [3, 6]].
    Элемент [j][i] результата равен A[i][j].
    """
    # TODO: ваш код
    ...


def matmul(A, B):
    """Матричное умножение: (m, n) @ (n, k) → (m, k).

    C[i][j] = сумма по t от A[i][t] * B[t][j] — «строка i на столбец j».
    Если внутренние размеры не совпадают, бросьте ValueError.
    Пример: matmul([[1, 2], [3, 4]], [[5, 6], [7, 8]]) → [[19, 22], [43, 50]]
    (19 = 1·5 + 2·7 — первая строка на первый столбец).
    """
    # TODO: m, n = shape(A); n2, k = shape(B); проверка n == n2; затем двойной цикл по i и j
    ...


def linear(X, W, b):
    """Линейный слой как в PyTorch (nn.Linear): Y = X @ Wᵀ + b.

    X — батч входов формы (batch, in), W — веса формы (out, in), b — список длины out.
    Возвращает матрицу формы (batch, out). Используйте свои transpose и matmul.
    Пример: linear([[1, 2]], [[1, 0], [0, 1], [1, 1]], [0, 0, 10]) → [[1, 2, 13]].
    """
    # TODO: Y = matmul(X, transpose(W)), затем к элементу столбца j каждой строки прибавьте b[j]
    ...


# Проверьте себя кнопкой «Запустить»:
A = [[1, 2, 3], [4, 5, 6]]
B = [[7, 8], [9, 10], [11, 12]]
print(shape(A), transpose(A))   # (2, 3) [[1, 4], [2, 5], [3, 6]]
print(matmul(A, B))             # [[58, 64], [139, 154]]
print(linear([[1, 2]], [[1, 0], [0, 1], [1, 1]], [0, 0, 10]))   # [[1, 2, 13]]

ЗапуститьПроверитьПодсказкаСбросить

Задание для Jupyter (по желанию). Возьмите своё matmul и замерьте время умножения матриц $n \times n$ для $n = 50, 100, 200$ через time.perf_counter(). Во сколько раз растёт время при удвоении $n$? Сравните с формулой $2n^3$ (подсказка: должно получиться около 8 раз). Затем сделайте то же для A @ B в NumPy при $n = 500, 1000, 2000$.

Китайский угол: «фанчэн» — таблица чисел на счётной доске

Две тысячи лет назад. В классическом трактате «Математика в девяти книгах» (окончательно сложился около начала нашей эры) восьмая глава называется «Фанчэн». Сегодня этим словом в китайском называют любое уравнение, а исходный смысл обычно объясняют как «числа, расставленные квадратом» — таблицей. Коэффициенты системы линейных уравнений раскладывали счётными палочками на доске в прямоугольник — по сути, в матрицу, только каждое уравнение записывали столбцом. Затем таблицу упрощали, вычитая столбцы друг из друга, — это тот же алгоритм, который в Европе позже назвали методом Гаусса. Комментарий к трактату в 263 году написал математик Лю Хуэй.

Первая задача главы: три снопа хорошего зерна, два среднего и один плохого дают 39 доу зерна (доу — старинная китайская мера объёма); два хорошего, три среднего и один плохого — 34 доу; один хороший, два средних и три плохих — 26 доу. Сколько зерна в одном снопе каждого сорта? Это система $A\mathbf{x} = \mathbf{b}$, которую сегодня решают одной строкой:

import numpy as np
A = np.array([[3, 2, 1], [2, 3, 1], [1, 2, 3]], dtype=float)
b = np.array([39, 34, 26], dtype=float)
print(np.linalg.solve(A, b))   # [9.25 4.25 2.75] — ответ трактата: 9¼, 4¼ и 2¾ доу

Сегодня. Китайский термин «матрица» буквально значит «прямоугольный строй». Умножение матриц инженеры называют GEMM (General Matrix Multiply), как функцию в библиотеке BLAS. В феврале 2025 года на «неделе открытого кода» DeepSeek выложила DeepGEMM (github.com/deepseek-ai/DeepGEMM) — свою библиотеку умножения матриц в формате FP8. По словам компании, на ней обучались и работают модели V3 и R1. Что такое FP8 и зачем считать матрицы в 8 битах, разберём в модуле 5.4.

Что посмотреть. В «Погружении в глубокое обучение» — разделы «Произведение матрицы на вектор» и «Умножение матриц» в главе 2.3. Для интуиции — главы 3 и 4 серии 3Blue1Brown «Сущность линейной алгебры» на Bilibili.

Проверь себя

Проверь себя6 вопросов·

1 Батч эмбеддингов формы $(32, 768)$ умножают на матрицу формы $(768, 3072)$. Какая форма у результата?

$(768, 768)$$(32, 3072)$$(3072, 32)$Умножить нельзя

2 Вычислите элемент во второй строке и первом столбце произведения $\begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix} \begin{pmatrix} 5 & 6 \\ 7 & 8 \end{pmatrix}$.

3 Какие утверждения верны?Можно выбрать несколько ответов

Для любых квадратных матриц $AB = BA$$(AB)^\top = B^\top A^\top$Первый столбец матрицы — это вектор, в который она переводит $\mathbf{e}_1 = (1, 0, \dots, 0)$Два линейных слоя подряд без функции активации можно заменить одним линейным слоем

4 Сколько обучаемых параметров у nn.Linear(512, 2048) (веса и смещение)?

5 Какую форму имеет nn.Linear(768, 3072).weight?

(768, 3072) — (in, out)(3072, 768) — (out, in)(3072,)(768,)

6 $A$ и $B$ — матрицы $4096 \times 4096$, $\mathbf{x}$ — вектор. Как дешевле вычислить $AB\mathbf{x}$?

Сначала $AB$, потом умножить на $\mathbf{x}$Сначала $B\mathbf{x}$, потом умножить на $A$Одинаково — результат ведь тот же

Проверить ответы

Итоги

• Матрица $m \times n$ — это линейное преобразование $\mathbb{R}^n \to \mathbb{R}^m$. Её столбцы — образы базисных векторов.
• $A\mathbf{x}$ — это и «строки на вектор» (так считать), и «комбинация столбцов» (так понимать).
• Умножение матриц — композиция преобразований: $(AB)\mathbf{x} = A(B\mathbf{x})$, формы $(m \times n)(n \times k) \to (m \times k)$, порядок важен, скобки переставлять можно, стоимость $\approx 2mnk$.
• Линейный слой — $Y = XW^\top + \mathbf{b}$; в PyTorch веса хранятся как (out, in). Без нелинейности стопка линейных слоёв равна одному слою.

Дальше: ранг и SVD — как понять, сколько информации на самом деле несёт матрица, и как сжать её в десятки раз. На этом стоят LoRA и MLA.