Матрицы: определение и виды 🔢
Часть 1: Теория и базовые задания
Знаешь, что общего между изображением кота в нейросети, рекомендацией фильма на Netflix и распознаванием твоего голоса Алексой? Все они работают с матрицами. Да-да, те самые прямоугольные таблички с числами, которые пугали в школе.
Но вот в чём фишка: матрицы — это не абстрактная математика для учебников . Это главный рабочий инструмент современного ML/AI. Когда ChatGPT генерирует текст, он перемножает матрицы. Когда DALL-E создаёт картинку — опять матрицы. Когда рекомендательная система предлагает тебе следующий ролик на YouTube — угадай что? Правильно, матрицы.
В этом уроке мы с тобой разберёмся с самых основ : что такое матрица, какие они бывают, и — самое интересное — где они используются в реальном ML . Не будет абстрактных примеров про яблоки. Вместо этого — embeddings, веса нейросетей, attention механизмы.
🎯 Что ты узнаешь в этой части:
Что такое матрица простыми словами (и почему это важнее, чем кажется)
Какие бывают виды матриц и зачем каждый нужен
Как матрицы хранят embeddings слов в ChatGPT
Почему форма матрицы критична для нейросетей
10 базовых заданий с подробными решениями
Что такое матрица? Начнём с нуля
Интуитивное понимание
Представь, что тебе нужно хранить информацию о 5 пользователях и их активности в 3 разных приложениях. Можно сделать так:
Пользователь 1: WhatsApp - 120 минут, Instagram - 45 минут, TikTok - 30 минут
Пользователь 2: WhatsApp - 80 минут, Instagram - 90 минут, TikTok - 60 минут
...
Читать неудобно, правда? А теперь представь то же самое в виде таблички :
WhatsApp Instagram TikTok
Юзер 1 120 45 30
Юзер 2 80 90 60
Юзер 3 150 20 10
Юзер 4 95 75 40
Юзер 5 110 55 25
Вот эта табличка с числами и есть матрица! Просто и понятно.
Математическая запись
Математики любят всё формализовать. Ту же табличку они запишут так:
$$A = \begin{pmatrix}
120 & 45 & 30 \\
80 & 90 & 60 \\
150 & 20 & 10 \\
95 & 75 & 40 \\
110 & 55 & 25
\end{pmatrix}$$Здесь:
Вся табличка называется матрицей и обозначается большой буквой (обычно $A$, $B$, $X$, $W$)
Строки (rows) — горизонтальные ряды чисел (их 5 штук)
Столбцы (columns) — вертикальные ряды чисел (их 3 штуки)
Каждое число в табличке — элемент матрицы
Строгое определение
Определение: Матрица — это прямоугольная таблица чисел, состоящая из $m$ строк и $n$ столбцов.
Обозначения:
$A$ — сама матрица
$m$ — количество строк (rows)
$n$ — количество столбцов (columns)
$a_{ij}$ — элемент в $i$-й строке и $j$-м столбце
Размер (shape): $m \times n$ (читается "эм на эн")
Общая форма:
$$A = \begin{pmatrix}
a_{11} & a_{12} & \cdots & a_{1n} \\
a_{21} & a_{22} & \cdots & a_{2n} \\
\vdots & \vdots & \ddots & \vdots \\
a_{m1} & a_{m2} & \cdots & a_{mn}
\end{pmatrix}$$Важно: Запись $a_{ij}$ — сначала номер строки, потом столбца. Это как адрес: "улица номер $i$, дом номер $j$".
Примеры с разбором
Пример 1 (простейший):
$$B = \begin{pmatrix}
1 & 2 & 3 \\
4 & 5 & 6
\end{pmatrix}$$Разбираем:
$b_{11} = 1$ (первая строка, первый столбец)
$b_{12} = 2$ (первая строка, второй столбец)
$b_{23} = 6$ (вторая строка, третий столбец)
Размер: $2 \times 3$
Пример 2 (рейтинги фильмов — реальная задача рекомендательных систем):
Три пользователя поставили оценки четырём фильмам:
$$R = \begin{pmatrix}
5 & 3 & 4 & 2 \\
4 & 5 & 3 & 4 \\
2 & 1 & 5 & 3
\end{pmatrix}$$Расшифровка:
Строки = пользователи (3)
Столбцы = фильмы (4)
$r_{11} = 5$ — первый пользователь поставил фильму №1 оценку 5
$r_{32} = 1$ — третий пользователь поставил фильму №2 оценку 1
Применение в ML: Именно так устроены рекомендательные системы Netflix! Алгоритм ищет паттерны в этой матрице, чтобы предсказать, какой фильм понравится тебе.
Пример 3 (ML — embeddings слов):
В NLP каждое слово представляется вектором чисел — word embedding . Все embeddings хранятся в матрице:
$$E = \begin{pmatrix}
0.2 & -0.5 & 0.8 & 0.1 \\
0.1 & 0.3 & -0.2 & 0.9 \\
-0.4 & 0.6 & 0.3 & -0.1 \\
0.7 & -0.2 & 0.5 & 0.4 \\
-0.3 & 0.8 & -0.6 & 0.2
\end{pmatrix}$$Что здесь:
Размер: $5 \times 4$ (5 слов, каждое описывается 4 числами)
В реальности: GPT-3 имеет матрицу embeddings $50257 \times 12288$ — 618 миллионов параметров только на embeddings!
Зачем это важно: Когда нейросеть обрабатывает текст "кот", она ищет слово "кот" в этой матрице и достаёт его вектор. Это первый шаг в любой NLP-модели.
Виды матриц: классификация
1. Прямоугольная матрица
Определение: $m \neq n$ (строк ≠ столбцов)
Где в ML:
Датасеты: 1000 примеров × 50 признаков = $(1000, 50)$
Веса Dense слоя: 128→64 = $(64, 128)$
Embeddings: 50k слов × 300 размерность = $(50000, 300)$
2. Квадратная матрица
Определение: $m = n$ (строк = столбцов)
Пример:
$$B = \begin{pmatrix}
1 & 2 & 3 \\
4 & 5 & 6 \\
7 & 8 & 9
\end{pmatrix}$$Размер: $3 \times 3$
Где в ML:
Матрица ковариаций: 10 признаков → $(10, 10)$
Attention scores: 512 токенов → $(512, 512)$
Confusion matrix: 10 классов → $(10, 10)$
Особенность: Только для квадратных матриц определены определитель, след, собственные значения.
3. Вектор-столбец
Определение: Матрица $m \times 1$ (один столбец)
$$\mathbf{v} = \begin{pmatrix}
1 \\
2 \\
3 \\
4
\end{pmatrix}$$Размер: $(4, 1)$
Где в ML:
Один пример из датасета: если 4 признака → $(4, 1)$
Выход нейросети для одного примера: 10 классов → $(10, 1)$
Градиенты при backprop
В коде:
import numpy as np
x = np. array([[5.1 ], [3.5 ], [1.4 ], [0.2 ]]) # (4, 1)
4. Вектор-строка
Определение: Матрица $1 \times n$ (одна строка)
$$\mathbf{w}^T = \begin{pmatrix}
1 & 2 & 3 & 4
\end{pmatrix}$$Размер: $(1, 4)$
Где в ML:
Веса одного нейрона
Одна строка датасета
Важно:
v_col = np. array([[1 ], [2 ], [3 ]]) # (3, 1)
v_row = np. array([[1 , 2 , 3 ]]) # (1, 3)
# Это РАЗНЫЕ вещи!
5. Нулевая матрица
Определение: Все элементы = 0
$$\mathbf{0}_{2 \times 3} = \begin{pmatrix}
0 & 0 & 0 \\
0 & 0 & 0
\end{pmatrix}$$Где в ML:
Инициализация bias в нейросетях
Padding в CNN (добавление нулей вокруг изображения)
Маски в attention
Свойство: $A + \mathbf{0} = A$ (аналог нуля для чисел)
6. Единичная матрица
Определение: На диагонали единицы, остальное — нули
$$I_3 = \begin{pmatrix}
1 & 0 & 0 \\
0 & 1 & 0 \\
0 & 0 & 1
\end{pmatrix}$$Формально:
$$I_n = (i_{ij}), \quad i_{ij} = \begin{cases}
1, & i = j \\
0, & i \neq j
\end{cases}$$Где в ML:
Ridge regression: добавляют $\lambda I$ к матрице
Обратные матрицы: $A \cdot A^{-1} = I$
Свойство: $A \cdot I = I \cdot A = A$ (аналог единицы для чисел)
В коде:
I = np. eye(5 ) # единичная 5×5
7. Диагональная матрица
Определение: Все элементы вне диагонали = 0
$$D = \begin{pmatrix}
3 & 0 & 0 \\
0 & -2 & 0 \\
0 & 0 & 5
\end{pmatrix}$$Обозначение: $D = \text{diag}(3, -2, 5)$
Где в ML:
Масштабирование признаков
Adam optimizer (свой learning rate для каждого параметра)
SVD разложение (матрица $\Sigma$)
Преимущество: Умножение на диагональную матрицу очень быстрое — в $O(n)$ вместо $O(n^3)$!
8. Симметричная матрица
Определение: $A = A^T$ (равна своей транспонированной)
$$S = \begin{pmatrix}
1 & 2 & 3 \\
2 & 4 & 5 \\
3 & 5 & 6
\end{pmatrix}$$Проверка: $s_{12} = 2 = s_{21}$, $s_{13} = 3 = s_{31}$, $s_{23} = 5 = s_{32}$ ✅
Где в ML:
Матрица ковариаций: $\text{Cov}(X) = \frac{1}{n} X^T X$ всегда симметрична
Kernel matrix в SVM
Hessian матрица (вторые производные)
Особенность: Симметричные матрицы имеют вещественные собственные значения и ортогональные собственные векторы.
9. Разреженная матрица (sparse)
Определение: Большинство элементов = 0
Пример:
$$S = \begin{pmatrix}
0 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
1 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 5 \\
0 & 2 & 0 & 0 & 0
\end{pmatrix}$$Ненулевых: 4 из 25 (16%)
Где в ML:
TF-IDF матрицы в NLP (документы × слова)
One-hot encoding
User-item матрицы в рекомендациях
Графы (adjacency matrix)
Пример: Если документ содержит 100 слов из словаря 10,000, то матрица на 99% состоит из нулей!
В коде:
from scipy.sparse import csr_matrix
# Sparse матрица 1000×1000 с 0.1% ненулевых
# Dense: ~8 MB, Sparse: ~80 KB!
Важность: Экономия памяти в 10-100 раз + ускорение вычислений.
Форма (shape) матрицы: почему это критично
Что такое shape?
Форма матрицы — её размеры: $(m, n)$ = строки × столбцы.
Почему shape критичен в ML?
1. Умножение возможно только при совместимых размерах:
Чтобы перемножить $A \times B$:
Столбцов в $A$ = строк в $B$
Если $A$: $(m, k)$ и $B$: $(k, n)$, то $C = A \times B$: $(m, n)$
Пример:
$A$: $(3, 5)$
$B$: $(5, 2)$
$C = A \times B$: $(3, 2)$ ✅
Но:
$A$: $(3, 5)$
$B$: $(2, 7)$
$C = A \times B$: ОШИБКА! ❌
2. Форма определяет операции в нейросетях:
В Dense слое: $\mathbf{y} = \sigma(W \mathbf{x} + \mathbf{b})$
Если:
$\mathbf{x}$: $(n_{\text{in}}, 1)$
$W$: $(n_{\text{out}}, n_{\text{in}})$
$\mathbf{b}$: $(n_{\text{out}}, 1)$
То:
$W \mathbf{x}$: $(n_{\text{out}}, n_{\text{in}}) \times (n_{\text{in}}, 1) = (n_{\text{out}}, 1)$ ✅
Ошибка в shape = Runtime Error в коде!
Матрицы в ML: реальные примеры
1. Датасет как матрица
$$X = \begin{pmatrix}
x_{11} & x_{12} & \cdots & x_{1n} \\
x_{21} & x_{22} & \cdots & x_{2n} \\
\vdots & \vdots & \ddots & \vdots \\
x_{m1} & x_{m2} & \cdots & x_{mn}
\end{pmatrix}$$
$m$ = примеры (samples)
$n$ = признаки (features)
Iris dataset: $(150, 4)$ — 150 цветков, 4 признака
2. Веса в нейросетях
Слой Dense с 512 входами и 256 выходами:
import torch.nn as nn
layer = nn. Linear(512 , 256 )
print(layer. weight. shape) # torch.Size([256, 512])
Параметров: $256 \times 512 + 256 = 131,328$
3. Embeddings матрица
В NLP каждое слово → вектор. Все векторы в матрице:
$$E \in \mathbb{R}^{V \times d}$$
$V$ = размер словаря
$d$ = размерность embedding
BERT base: $(30522, 768)$
GPT-3: $(50257, 12288)$ — 618 млн параметров!
4. Attention матрица
Для последовательности из $n$ токенов: матрица attention scores $n \times n$
Пример (5 слов):
I love machine learning today
I 0.9 0.05 0.02 0.02 0.01
love 0.1 0.6 0.15 0.1 0.05
machine 0.05 0.1 0.5 0.3 0.05
learning 0.05 0.1 0.4 0.4 0.05
today 0.3 0.2 0.1 0.1 0.3
Проблема: Для $n=2048$ (GPT-3) → матрица $2048 \times 2048 = 4.2$ млн элементов!
5. Изображение как матрица
Grayscale MNIST: $(28, 28)$ — яркость каждого пикселя 0-255
RGB ImageNet: $(224, 224, 3)$ — три матрицы для R, G, B каналов
В PyTorch:
img = torch. randn(3 , 224 , 224 ) # (channels, height, width)
Практика: Базовые задания (1-10)
Задание 1
Определите размер матрицы:
$$A = \begin{pmatrix}
1 & 2 \\
3 & 4 \\
5 & 6
\end{pmatrix}$$
Показать решение 👇
Решение:
Считаем строки: 3 (три горизонтальных ряда)
Считаем столбцы: 2 (по 2 числа в каждой строке)
Ответ: $3 \times 2$
Задание 2
Найдите элемент $a_{23}$ в матрице:
$$A = \begin{pmatrix}
10 & 20 & 30 \\
40 & 50 & 60
\end{pmatrix}$$
Показать решение 👇
Решение:
$a_{23}$ означает: строка 2, столбец 3
Вторая строка: [40, 50, 60]
Третий столбец второй строки: 60
Ответ: $a_{23} = 60$
Задание 3
Является ли квадратной матрица:
$$B = \begin{pmatrix}
1 & 0 \\
0 & 1
\end{pmatrix}$$
Показать решение 👇
Решение:
Квадратная матрица: $m = n$ (строк = столбцов)
Строк: 2
Столбцов: 2
$2 = 2$ ✅
Ответ: Да, квадратная матрица $2 \times 2$ (это единичная матрица $I_2$)
Задание 4
Создайте нулевую матрицу $2 \times 3$
Показать решение 👇
Решение:
2 строки, 3 столбца, все элементы = 0:
$$\mathbf{0}_{2 \times 3} = \begin{pmatrix}
0 & 0 & 0 \\
0 & 0 & 0
\end{pmatrix}$$
Ответ: $\begin{pmatrix} 0 & 0 & 0 \\ 0 & 0 & 0 \end{pmatrix}$
Задание 5
Запишите единичную матрицу $I_3$
Показать решение 👇
Решение:
На диагонали единицы, остальное — нули:
$$I_3 = \begin{pmatrix}
1 & 0 & 0 \\
0 & 1 & 0 \\
0 & 0 & 1
\end{pmatrix}$$
Ответ: $\begin{pmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix}$
Задание 6
Симметрична ли матрица:
$$S = \begin{pmatrix}
5 & 2 \\
2 & 3
\end{pmatrix}$$
Показать решение 👇
Решение:
Проверяем $s_{12}$ vs $s_{21}$:
$s_{12} = 2$, $s_{21} = 2$ → $2 = 2$ ✅
Ответ: Да, симметрична
Задание 7
Сколько параметров в слое Dense(100 → 50) с bias?
Показать решение 👇
Решение:
Веса: $50 \times 100 = 5000$
Bias: $50$
Всего: $5000 + 50 = 5050$
Формула: $n_{\text{out}} \times (n_{\text{in}} + 1) = 50 \times 101 = 5050$
Ответ: 5050 параметров
Задание 8
Сколько элементов в матрице $m \times n$?
Показать решение 👇
Решение:
$m$ строк × $n$ столбцов в каждой
Всего: $m \times n$ элементов
Пример: Матрица $3 \times 4$ имеет $3 \times 4 = 12$ элементов
Ответ: $m \times n$
Задание 9
Можно ли транспонировать матрицу $2 \times 5$? Какой размер результата?
Показать решение 👇
Решение:
Транспонировать можно ЛЮБУЮ матрицу.
При транспонировании строки и столбцы меняются местами.
$2 \times 5$ → после транспонирования → $5 \times 2$
Ответ: Да, можно. Размер: $5 \times 2$
Задание 10
Запишите вектор-столбец с элементами 3, 7, -2, 5
Показать решение 👇
Решение:
Вектор-столбец — матрица $m \times 1$
4 элемента → размер $4 \times 1$:
$$\mathbf{v} = \begin{pmatrix}
3 \\
7 \\
-2 \\
5
\end{pmatrix}$$
Ответ: $\begin{pmatrix} 3 \\ 7 \\ -2 \\ 5 \end{pmatrix}$
Главное запомнить
📝 Ключевые понятия
✅ Матрица — прямоугольная таблица чисел размера $m \times n$
✅ Элемент $a_{ij}$ — строка $i$, столбец $j$ (ВАЖЕН порядок!)
✅ Shape критичен — без правильной формы нейросеть не работает
✅ Квадратная матрица — $m = n$ (нужна для определителя, собственных значений)
✅ Единичная $I$ — на диагонали 1, остальное 0. Свойство: $AI = IA = A$
✅ Симметричная — $A = A^T$. Важна в ковариациях, kernel matrix
✅ Sparse матрица — большинство нулей. Экономит память в 10-100 раз!
✅ В ML всё — матрицы:
Датасет: $(m, n)$ — примеры × признаки
Веса Dense: $(n_{\text{out}}, n_{\text{in}})$
Embeddings: $(V, d)$ — словарь × размерность
Attention: $(n, n)$ — токены × токены
Изображение: $(H, W, C)$ — высота × ширина × каналы
💡 Совет: Матрицы — это фундамент ML. Если хочешь понимать, как работают нейросети "под капотом", нужно понимать матрицы. Это не абстракция — это рабочий инструмент каждого ML-инженера.
Матрицы: Часть 2 🎯
Средние задания (11-20)
Продолжаем практику! В этой части задания становятся интереснее — мы работаем с реальными сценариями из машинного обучения.
Задание 11
Создайте диагональную матрицу D=diag(2,−1,3)D = \text{diag}(2, -1, 3)
D=diag(2,−1,3)
Показать решение 👇
Решение:
Шаг 1: diag(2,−1,3)\text{diag}(2, -1, 3)
diag(2,−1,3) означает: на диагонали числа 2, -1, 3, остальное — нули
Шаг 2: Размер = 3 диагональных элемента → матрица 3×33 \times 3
3×3
Шаг 3: Заполняем диагональ:
d11=2d_{11} = 2
d11=2
d22=−1d_{22} = -1
d22=−1
d33=3d_{33} = 3
d33=3
Шаг 4: Остальные элементы = 0
$$D = \begin{pmatrix}
2 & 0 & 0 \
0 & -1 & 0 \
0 & 0 & 3
\end{pmatrix}$$
В коде:
pythonimport numpy as np
D = np.diag([2, -1, 3])
Ответ: (2000−10003)\begin{pmatrix} 2 & 0 & 0 \ 0 & -1 & 0 \ 0 & 0 & 3 \end{pmatrix}
2000−10003
Задание 12
Дан датасет из 200 изображений 32×3232 \times 32
32×32 RGB. Какой shape матрицы данных?
Показать решение 👇
Решение:
Шаг 1: Одно RGB изображение 32×3232 \times 32
32×32 имеет 3 канала
Shape одного: (3,32,32)(3, 32, 32)
(3,32,32) в формате channels-first
Шаг 2: У нас 200 изображений
Добавляем размерность батча: (N,C,H,W)(N, C, H, W)
(N,C,H,W)
Шаг 3: Подставляем:
N=200N = 200
N=200 (количество изображений)
C=3C = 3
C=3 (RGB каналы)
H=32H = 32
H=32 (высота)
W=32W = 32
W=32 (ширина)
Шаг 4: Итоговый shape: (200,3,32,32)(200, 3, 32, 32)
(200,3,32,32)
Альтернативно (channels-last): (200,32,32,3)(200, 32, 32, 3)
(200,32,32,3) в TensorFlow
Количество элементов: 200×3×32×32=614,400200 \times 3 \times 32 \times 32 = 614,400
200×3×32×32=614,400 чисел!
В коде:
pythonimport torch
images = torch.randn(200, 3, 32, 32)
print(images.shape) # torch.Size([200, 3, 32, 32])
Ответ: (200,3,32,32)(200, 3, 32, 32)
(200,3,32,32) или (200,32,32,3)(200, 32, 32, 3)
(200,32,32,3) в зависимости от формата
Задание 13
Можно ли перемножить матрицу 4×34 \times 3
4×3 на 3×53 \times 5
3×5? Какой размер результата?
Показать решение 👇
Решение:
Шаг 1: Правило умножения матриц:
(m,k)×(k,n)=(m,n)(m, k) \times (k, n) = (m, n)
(m,k)×(k,n)=(m,n) — столбцы первой = строки второй
Шаг 2: Проверяем:
AA
A: 4×34 \times 3
4×3 (4 строки, 3 столбца)
BB
B: 3×53 \times 5
3×5 (3 строки, 5 столбцов)
Столбцов в AA
A: 3
Строк в BB
B: 3
3=33 = 3
3=3 ✅ — совместимы!
Шаг 3: Размер результата:
(4,3)×(3,5)=(4,5)(4, 3) \times (3, 5) = (4, 5)
(4,3)×(3,5)=(4,5)
Визуально:
A: 4 строки × 3 столбца
B: 3 строки × 5 столбцов
↓ совпадают ↓
C: 4 строки × 5 столбцов
Проверка: Каждый из 20 элементов результата вычисляется как скалярное произведение строки AA
A на столбец BB
B.
Ответ: Да, можно. Размер: 4×54 \times 5
4×5
Задание 14
Создайте верхнетреугольную матрицу 3×33 \times 3
3×3 с ненулевыми элементами
Показать решение 👇
Решение:
Шаг 1: Верхнетреугольная = все элементы НИЖЕ диагонали = 0
Шаг 2: Элементы ниже диагонали (где i>ji > j
i>j):
u21,u31,u32u_{21}, u_{31}, u_{32}
u21,u31,u32 должны быть = 0
Шаг 3: Остальные можем выбрать произвольно:
$$U = \begin{pmatrix}
1 & 4 & 7 \
0 & 2 & 5 \
0 & 0 & 3
\end{pmatrix}$$
Проверка:
u21=0u_{21} = 0
u21=0 ✅
u31=0u_{31} = 0
u31=0 ✅
u32=0u_{32} = 0
u32=0 ✅
Альтернатива:
$$U = \begin{pmatrix}
5 & -2 & 8 \
0 & 3 & 1 \
0 & 0 & -4
\end{pmatrix}$$
В коде:
pythonA = np.random.randint(-10, 10, (3, 3))
U = np.triu(A) # upper triangle
Ответ: Например, (147025003)\begin{pmatrix} 1 & 4 & 7 \ 0 & 2 & 5 \ 0 & 0 & 3 \end{pmatrix}
100420753
Задание 15
Для последовательности из 10 токенов в трансформере, какой размер attention матрицы?
Показать решение 👇
Решение:
Шаг 1: В self-attention каждый токен "смотрит" на все токены
Шаг 2: Нужна матрица n×nn \times n
n×n, где:
Строки = токены-запросы
Столбцы = токены-ключи
AijA_{ij}
Aij = насколько токен ii
i смотрит на токен jj
j
Шаг 3: Для n=10n = 10
n=10 токенов:
Размер: 10×1010 \times 10
10×10
Шаг 4: Визуализация
T1 T2 T3 ... T10
T1 0.9 0.05 0.02 ... 0.01
T2 0.1 0.8 0.15 ... 0.02
... ... ... ... ... ...
T10 0.05 0.1 0.1 ... 0.7
Всего элементов: 10×10=10010 \times 10 = 100
10×10=100
Почему квадратичная сложность — проблема:
Для n=2048n=2048
n=2048 (GPT-3): 20482=4,194,3042048^2 = 4,194,304
20482=4,194,304 элемента!
Память: O(n2)O(n^2)
O(n2)
Вычисления: O(n2)O(n^2)
O(n2)
Поэтому придумали:
Sparse attention
Sliding window
Linear attention
Ответ: 10×1010 \times 10
10×10 (квадратная матрица)
Задание 16
Симметрична ли матрица:
$$M = \begin{pmatrix}
1 & 2 & 3 \
2 & 4 & 5 \
3 & 6 & 7
\end{pmatrix}$$
Показать решение 👇
Решение:
Шаг 1: Условие симметричности: mij=mjim_{ij} = m_{ji}
mij=mji для всех i,ji, j
i,j
Шаг 2: Проверяем пары:
m12=2m_{12} = 2
m12=2, m21=2m_{21} = 2
m21=2 → 2=22 = 2
2=2 ✅
m13=3m_{13} = 3
m13=3, m31=3m_{31} = 3
m31=3 → 3=33 = 3
3=3 ✅
m23=5m_{23} = 5
m23=5, m32=6m_{32} = 6
m32=6 → 5≠65 \neq 6
5=6 ❌
Шаг 3: Нашли несовпадение!
Вывод: Матрица НЕ симметрична
Проверка транспонированием:
$$M^T = \begin{pmatrix}
1 & 2 & 3 \
2 & 4 & 6 \
3 & 5 & 7
\end{pmatrix}$$
M≠MTM \neq M^T
M=MT
Ответ: Нет, не симметрична (m23=5≠6=m32m_{23} = 5 \neq 6 = m_{32}
m23=5=6=m32)
Задание 17
MNIST изображение 28×2828 \times 28
28×28 после flatten — какой shape?
Показать решение 👇
Решение:
Шаг 1: Flatten = преобразование многомерного массива в одномерный
Шаг 2: Исходное изображение: (28,28)(28, 28)
(28,28)
Элементов: 28×28=78428 \times 28 = 784
28×28=784
Шаг 3: После flatten:
Вектор-столбец: (784,1)(784, 1)
(784,1)
Или одномерный array: (784,)(784,)
(784,)
Процесс:
Исходное (28×28):
[pixel_1 pixel_2 ... pixel_28 ] строка 1
[pixel_29 pixel_30 ... pixel_56 ] строка 2
...
[pixel_757 pixel_758 ... pixel_784] строка 28
↓ flatten
Вектор (784×1):
[pixel_1 ]
[pixel_2 ]
...
[pixel_784]
В коде:
pythonfrom keras.datasets import mnist
(x_train, _), _ = mnist.load_data()
img = x_train[0] # (28, 28)
img_flat = img.flatten() # (784,)
img_col = img.reshape(784, 1) # (784, 1)
Ответ: (784,)(784,)
(784,) или (784,1)(784, 1)
(784,1) для вектора-столбца
Задание 18
Embedding матрица 50000×76850000 \times 768
50000×768 — сколько параметров?
Показать решение 👇
Решение:
Шаг 1: Каждый элемент матрицы = обучаемый параметр
Шаг 2: Для матрицы m×nm \times n
m×n:
Параметров = m×nm \times n
m×n
Шаг 3: Вычисляем:
50000×768=38,400,00050000 \times 768 = 38,400,000
50000×768=38,400,000
Шаг 4: Переводим:
38.438.4
38.4 миллиона параметров
В байтах (float32 = 4 байта):
38,400,000×4=153,600,00038,400,000 \times 4 = 153,600,000
38,400,000×4=153,600,000 байт = 153.6153.6
153.6 МБ
Сравнение:
BERT-base: 30522×768=23.430522 \times 768 = 23.4
30522×768=23.4 млн
GPT-3: 50257×12288=61850257 \times 12288 = 618
50257×12288=618 млн!
Ответ: 38,400,000 параметров (38.4 млн)
Задание 19
Является ли единичная матрица InI_n
In диагональной? Симметричной?
Показать решение 👇
Решение:
Часть 1: Диагональная?
Шаг 1: Диагональная матрица = все элементы вне диагонали = 0
Шаг 2: Единичная матрица I3I_3
I3:
$$I_3 = \begin{pmatrix}
1 & 0 & 0 \
0 & 1 & 0 \
0 & 0 & 1
\end{pmatrix}$$
Шаг 3: Вне диагонали все нули ✅
Вывод: Да, InI_n
In — диагональная (частный случай с единицами на диагонали)
Часть 2: Симметричная?
Шаг 1: Симметричная = A=ATA = A^T
A=AT
Шаг 2: Транспонируем:
$$I_3^T = \begin{pmatrix}
1 & 0 & 0 \
0 & 1 & 0 \
0 & 0 & 1
\end{pmatrix}$$
Шаг 3: I3=I3TI_3 = I_3^T
I3=I3T ✅
Почему: Единичная матрица симметрична относительно диагонали — везде одинаковые элементы (единицы на диагонали, нули вне)
Ответ:
Да, диагональная
Да, симметричная
Задание 20
Создайте confusion matrix для бинарной классификации:
TN=85, FP=10, FN=5, TP=90
Показать решение 👇
Решение:
Шаг 1: Структура confusion matrix 2×22 \times 2
2×2:
$$CM = \begin{pmatrix}
TN & FP \
FN & TP
\end{pmatrix}$$
Где:
TN (True Negative) = правильно предсказан класс 0
FP (False Positive) = ошибочно предсказан класс 1
FN (False Negative) = ошибочно предсказан класс 0
TP (True Positive) = правильно предсказан класс 1
Шаг 2: Подставляем данные:
TN = 85
FP = 10
FN = 5
TP = 90
$$CM = \begin{pmatrix}
85 & 10 \
5 & 90
\end{pmatrix}$$
Шаг 3: Интерпретация:
Предсказано
Класс 0 Класс 1
Истина Класс 0 85 10 (95 всего)
Класс 1 5 90 (95 всего)
Из 95 примеров класса 0: 85 правильно, 10 ошибочно
Из 95 примеров класса 1: 90 правильно, 5 ошибочно
Шаг 4: Метрики:
Accuracy:
TN+TPTotal=85+90190=175190≈0.92=92%\frac{TN + TP}{Total} = \frac{85 + 90}{190} = \frac{175}{190} \approx 0.92 = 92%TotalTN+TP=19085+90=190175≈0.92=92%
Precision:
TPTP+FP=90100=0.9=90%\frac{TP}{TP + FP} = \frac{90}{100} = 0.9 = 90%TP+FPTP=10090=0.9=90%
Recall:
TPTP+FN=9095≈0.947=94.7%\frac{TP}{TP + FN} = \frac{90}{95} \approx 0.947 = 94.7%TP+FNTP=9590≈0.947=94.7%
Ответ: (8510590)\begin{pmatrix} 85 & 10 \ 5 & 90 \end{pmatrix}
(8551090)
Главное из второй части
📊 Что освоили:
✅ Диагональные матрицы — быстрые в вычислениях, используются в оптимизации
✅ Shape для батчей — (N,C,H,W)(N, C, H, W)
(N,C,H,W) формат критичен для CNN
✅ Совместимость размеров — основа матричного умножения в нейросетях
✅ Треугольные матрицы — важны в LU-разложении и решении систем
✅ Attention матрицы — квадратичная сложность O(n2)O(n^2)
O(n2) — главная проблема трансформеров
✅ Flatten операция — 28×28→78428 \times 28 \rightarrow 784
28×28→784 для подачи в Dense слой
✅ Embeddings — миллионы параметров в одной матрице!
✅ Confusion Matrix — квадратная матрица для оценки классификации
💡 Совет: Обрати внимание, как часто в ML встречаются квадратные матрицы (attention, ковариации, confusion). Это не случайность — квадратные матрицы обладают особыми свойствами (собственные значения, определитель), которые критичны для анализа данных.
Продвинутые задания (21-30)
Финальная часть! Здесь мы работаем с реальными архитектурами нейросетей, считаем параметры, разбираемся с ковариациями и attention механизмами.
Задание 21
Вычислите параметры нейросети:
Input(784) → Dense(128) → Dense(64) → Dense(10), все слои с bias
Показать решение 👇
Решение:
Шаг 1: Формула для Dense слоя:
Параметры = nout×(nin+1)n_{\text{out}} \times (n_{\text{in}} + 1)
nout×(nin+1)
Слой 1: 784 → 128
Веса: 128×784=100,352128 \times 784 = 100,352
128×784=100,352
Bias: 128128
128
Всего: 100,352+128=100,480100,352 + 128 = 100,480
100,352+128=100,480
Или: 128×(784+1)=128×785=100,480128 \times (784 + 1) = 128 \times 785 = 100,480
128×(784+1)=128×785=100,480 ✅
Слой 2: 128 → 64
Веса: 64×128=8,19264 \times 128 = 8,192
64×128=8,192
Bias: 6464
64
Всего: 8,192+64=8,2568,192 + 64 = 8,256
8,192+64=8,256
Или: 64×129=8,25664 \times 129 = 8,256
64×129=8,256 ✅
Слой 3: 64 → 10
Веса: 10×64=64010 \times 64 = 640
10×64=640
Bias: 1010
10
Всего: 640+10=650640 + 10 = 650
640+10=650
Или: 10×65=65010 \times 65 = 650
10×65=650 ✅
Шаг 2: Суммируем:
100,480+8,256+650=109,386100,480 + 8,256 + 650 = 109,386100,480+8,256+650=109,386
Проверка (Keras):
pythonfrom keras.models import Sequential
from keras.layers import Dense
model = Sequential([
Dense(128, input_shape=(784,)),
Dense(64),
Dense(10)
])
model.summary()
Total params: 109,386
Распределение:
Слой 1: 100,480 (92%!) — первый слой доминирует
Слой 2: 8,256 (7.5%)
Слой 3: 650 (0.6%)
Ответ: 109,386 параметров
Задание 22
One-hot encoding для словаря из 10,000 слов. Shape вектора для одного слова? Shape для предложения из 15 слов?
Показать решение 👇
Решение:
Шаг 1: One-hot encoding = вектор длины = размеру словаря
Для одного слова:
Словарь 10,000 слов → вектор длины 10,000
Все нули, кроме одной единицы
Пример (словарь из 5 слов):
["кот", "собака", "мышь", "птица", "рыба"]
Слово "мышь" (индекс 2): [0,0,1,0,0][0, 0, 1, 0, 0]
[0,0,1,0,0]
Shape для одного слова: (10000,1)(10000, 1)
(10000,1) или (10000,)(10000,)
(10000,)
Для предложения из 15 слов:
Шаг 2: Складываем 15 one-hot векторов в матрицу
Строки = слова (15)
Столбцы = one-hot вектор (10,000)
Shape: (15,10000)(15, 10000)
(15,10000)
Визуализация:
Слово 1: [0, 0, 1, 0, ..., 0] 10000 элементов
Слово 2: [0, 0, 0, 1, ..., 0]
...
Слово 15: [0, 0, 0, 0, ..., 1]
↑
(15, 10000)
Шаг 3: Анализ разреженности
Всего элементов: 15×10000=150,00015 \times 10000 = 150,000
15×10000=150,000
Ненулевых: 15 (по одной единице на слово)
Доля ненулевых: 15150000=0.0001=0.01%\frac{15}{150000} = 0.0001 = 0.01%
15000015=0.0001=0.01%
Вывод: Очень sparse! 99.99% — нули.
Код:
pythonvocab_size = 10000
sentence_length = 15
One-hot матрица
one_hot = np.zeros((sentence_length, vocab_size))
word_indices = [42, 108, 5, ...] # индексы слов
for i, idx in enumerate(word_indices):
one_hot[i, idx] = 1
print(one_hot.shape) # (15, 10000)
print(np.count_nonzero(one_hot)) # 15
Почему неэффективно:
Огромные размеры
99.99% памяти на нули
Нет семантики
→ Поэтому используют embeddings!
Ответ:
Один вектор: (10000,1)(10000, 1)
(10000,1)
Предложение: (15,10000)(15, 10000)
(15,10000)
Задание 23
Проверьте вручную: I2×A=AI_2 \times A = A
I2×A=A для A=(123456)A = \begin{pmatrix} 1 & 2 & 3 \ 4 & 5 & 6 \end{pmatrix}
A=(142536)
Показать решение 👇
Решение:
Шаг 1: Единичная матрица:
$$I_2 = \begin{pmatrix}
1 & 0 \
0 & 1
\end{pmatrix}$$
Шаг 2: Проверяем совместимость:
I2I_2
I2: (2,2)(2, 2)
(2,2)
AA
A: (2,3)(2, 3)
(2,3)
Столбцы I2I_2
I2 = 2 = строки AA
A ✅
Результат: (2,3)(2, 3)
(2,3)
Шаг 3: Умножаем по правилу
Элемент c11c_{11}
c11:
Первая строка I2I_2
I2: [1,0][1, 0]
[1,0]
Первый столбец AA
A: (14)\begin{pmatrix} 1 \ 4 \end{pmatrix}
(14)
c11=1⋅1+0⋅4=1c_{11} = 1 \cdot 1 + 0 \cdot 4 = 1c11=1⋅1+0⋅4=1
Элемент c12c_{12}
c12:
c12=1⋅2+0⋅5=2c_{12} = 1 \cdot 2 + 0 \cdot 5 = 2c12=1⋅2+0⋅5=2
Элемент c13c_{13}
c13:
c13=1⋅3+0⋅6=3c_{13} = 1 \cdot 3 + 0 \cdot 6 = 3c13=1⋅3+0⋅6=3
Элемент c21c_{21}
c21:
Вторая строка I2I_2
I2: [0,1][0, 1]
[0,1]
Первый столбец AA
A: (14)\begin{pmatrix} 1 \ 4 \end{pmatrix}
(14)
c21=0⋅1+1⋅4=4c_{21} = 0 \cdot 1 + 1 \cdot 4 = 4c21=0⋅1+1⋅4=4
Элемент c22c_{22}
c22:
c22=0⋅2+1⋅5=5c_{22} = 0 \cdot 2 + 1 \cdot 5 = 5c22=0⋅2+1⋅5=5
Элемент c23c_{23}
c23:
c23=0⋅3+1⋅6=6c_{23} = 0 \cdot 3 + 1 \cdot 6 = 6c23=0⋅3+1⋅6=6
Шаг 4: Собираем результат:
$$C = I_2 \times A = \begin{pmatrix}
1 & 2 & 3 \
4 & 5 & 6
\end{pmatrix} = A$$
Вывод: I×A=AI \times A = A
I×A=A ✅ (свойство единичной матрицы)
Геометрическая интерпретация: Единичная матрица — это "ничегонеделание", как умножение на 1 для чисел.
Ответ: Проверено, I2×A=AI_2 \times A = A
I2×A=A
Задание 24
CNN слой Conv2D: вход 224×224×3224 \times 224 \times 3
224×224×3, 64 фильтра 3×33 \times 3
3×3. Сколько параметров (с bias)?
Показать решение 👇
Решение:
Шаг 1: Структура Conv2D слоя
Один фильтр: тензор F×F×CF \times F \times C
F×F×C
Где:
F=3F = 3
F=3 (размер фильтра)
C=3C = 3
C=3 (входные каналы RGB)
Шаг 2: Параметры одного фильтра
Размер: 3×3×3=273 \times 3 \times 3 = 27
3×3×3=27 параметров
Шаг 3: Всего фильтров: 64
Параметры в весах:
64×27=1,72864 \times 27 = 1,728
64×27=1,728
Формула: Веса = K×F×F×CK \times F \times F \times C
K×F×F×C
=64×3×3×3=1,728= 64 \times 3 \times 3 \times 3 = 1,728
=64×3×3×3=1,728
Шаг 4: Добавляем bias
Каждый фильтр имеет 1 bias → 64 bias
Шаг 5: Итого:
1,728+64=1,792 параметра1,728 + 64 = 1,792 \text{ параметра}1,728+64=1,792 параметра
Проверка (PyTorch):
pythonimport torch.nn as nn
conv = nn.Conv2d(in_channels=3,
out_channels=64,
kernel_size=3,
bias=True)
total = sum(p.numel() for p in conv.parameters())
print(total) # 1792
ВАЖНО: Размер входа (224×224)(224 \times 224)
(224×224) НЕ влияет на количество параметров!
Это свойство CNN — одни и те же фильтры работают на изображениях любого размера.
Ответ: 1,792 параметра (1,728 весов + 64 bias)
Задание 25
Почему матрица ковариаций всегда симметрична?
Показать решение 👇
Решение:
Шаг 1: Определение ковариации
Ковариация признаков XX
X и YY
Y:
Cov(X,Y)=1n−1∑i=1n(xi−xˉ)(yi−yˉ)\text{Cov}(X, Y) = \frac{1}{n-1} \sum_{i=1}^{n} (x_i - \bar{x})(y_i - \bar{y})Cov(X,Y)=n−11i=1∑n(xi−xˉ)(yi−yˉ)
Ключевое свойство: Cov(X,Y)=Cov(Y,X)\text{Cov}(X, Y) = \text{Cov}(Y, X)
Cov(X,Y)=Cov(Y,X)
Почему:
(xi−xˉ)(yi−yˉ)=(yi−yˉ)(xi−xˉ)(x_i - \bar{x})(y_i - \bar{y}) = (y_i - \bar{y})(x_i - \bar{x})
(xi−xˉ)(yi−yˉ)=(yi−yˉ)(xi−xˉ) (коммутативность умножения)
Шаг 2: Матрица ковариаций
Для датасета с nn
n признаками:
$$\Sigma = \begin{pmatrix}
\text{Cov}(X_1, X_1) & \text{Cov}(X_1, X_2) & \cdots & \text{Cov}(X_1, X_n) \
\text{Cov}(X_2, X_1) & \text{Cov}(X_2, X_2) & \cdots & \text{Cov}(X_2, X_n) \
\vdots & \vdots & \ddots & \vdots \
\text{Cov}(X_n, X_1) & \text{Cov}(X_n, X_2) & \cdots & \text{Cov}(X_n, X_n)
\end{pmatrix}$$
Шаг 3: Проверка симметрии
Элемент (i,j)(i, j)
(i,j): Σij=Cov(Xi,Xj)\Sigma_{ij} = \text{Cov}(X_i, X_j)
Σij=Cov(Xi,Xj)
Элемент (j,i)(j, i)
(j,i): Σji=Cov(Xj,Xi)\Sigma_{ji} = \text{Cov}(X_j, X_i)
Σji=Cov(Xj,Xi)
Но Cov(Xi,Xj)=Cov(Xj,Xi)\text{Cov}(X_i, X_j) = \text{Cov}(X_j, X_i)
Cov(Xi,Xj)=Cov(Xj,Xi) ✅
→ Σij=Σji\Sigma_{ij} = \Sigma_{ji}
Σij=Σji для всех i,ji, j
i,j
→ Σ=ΣT\Sigma = \Sigma^T
Σ=ΣT → матрица симметрична!
Шаг 4: Пример (3 признака)
$$\Sigma = \begin{pmatrix}
\text{Var}(X_1) & \text{Cov}(X_1, X_2) & \text{Cov}(X_1, X_3) \
\text{Cov}(X_2, X_1) & \text{Var}(X_2) & \text{Cov}(X_2, X_3) \
\text{Cov}(X_3, X_1) & \text{Cov}(X_3, X_2) & \text{Var}(X_3)
\end{pmatrix}$$
Обрати внимание:
Диагональ: дисперсии (всегда положительные)
Вне диагонали: ковариации (симметричны!)
Код:
pythonX = np.random.randn(100, 3)
cov_matrix = np.cov(X.T)
Проверка симметрии
print(np.allclose(cov_matrix, cov_matrix.T)) # True
Ответ: Матрица ковариаций симметрична, потому что Cov(X,Y)=Cov(Y,X)\text{Cov}(X, Y) = \text{Cov}(Y, X)
Cov(X,Y)=Cov(Y,X) (коммутативность ковариации)
Задание 26
Batch из 32 примеров проходит через Dense(256 → 128). Какой shape входа? Какой shape выхода?
Показать решение 👇
Решение:
Шаг 1: Понимаем Dense слой для батча
Для одного примера: вход (256,1)(256, 1)
(256,1) → выход (128,1)(128, 1)
(128,1)
Для батча из BB
B примеров все примеры обрабатываются параллельно.
Шаг 2: Shape входа
B=32B = 32
B=32 примера, каждый по 256 признаков
Shape входа: (32,256)(32, 256)
(32,256)
В коде:
pythonx_batch = torch.randn(32, 256)
Шаг 3: Операция Dense слоя
Y=XWT+bY = XW^T + bY=XWT+b
Где:
XX
X: (B,nin)(B, n_{\text{in}})
(B,nin) = (32,256)(32, 256)
(32,256)
WW
W: (nout,nin)(n_{\text{out}}, n_{\text{in}})
(nout,nin) = (128,256)(128, 256)
(128,256)
bb
b: (nout,)(n_{\text{out}},)
(nout,) = (128,)(128,)
(128,) (будет broadcast'иться)
YY
Y: (B,nout)(B, n_{\text{out}})
(B,nout) = (32,128)(32, 128)
(32,128)
Шаг 4: Проверка размеров
XWTXW^T
XWT:
(32,256)×(256,128)=(32,128)(32, 256) \times (256, 128) = (32, 128)
(32,256)×(256,128)=(32,128) ✅
+b+ b
+b:
(32,128)+(128,)(32, 128) + (128,)
(32,128)+(128,) → broadcasting → (32,128)(32, 128)
(32,128) ✅
Код:
pythonimport torch.nn as nn
layer = nn.Linear(256, 128)
x = torch.randn(32, 256)
y = layer(x)
print(x.shape) # torch.Size([32, 256])
print(y.shape) # torch.Size([32, 128])
Ответ:
Вход: (32,256)(32, 256)
(32,256)
Выход: (32,128)(32, 128)
(32,128)
Задание 27
Сколько параметров в Embedding слое для словаря 30,000 слов с размерностью 512?
Показать решение 👇
Решение:
Шаг 1: Структура Embedding слоя
Embedding матрица: (V,d)(V, d)
(V,d)
Где:
VV
V = размер словаря
dd
d = размерность embedding
Шаг 2: Подставляем значения
V=30,000V = 30,000
V=30,000
d=512d = 512
d=512
Параметров = V×d=30,000×512V \times d = 30,000 \times 512
V×d=30,000×512
Шаг 3: Вычисляем
30,000×512=15,360,00030,000 \times 512 = 15,360,00030,000×512=15,360,000
В миллионах: 15.36 млн параметров
Шаг 4: В байтах (float32)
15,360,000×4=61,440,00015,360,000 \times 4 = 61,440,000
15,360,000×4=61,440,000 байт
=61.44= 61.44
=61.44 МБ
Код:
pythonimport torch.nn as nn
embedding = nn.Embedding(30000, 512)
params = sum(p.numel() for p in embedding.parameters())
print(f"Параметров: {params:,}") # 15,360,000
Сравнение:
BERT-base (30k × 768): 23 млн
GPT-2 (50k × 768): 38 млн
GPT-3 (50k × 12288): 618 млн!
Ответ: 15,360,000 параметров (15.36 млн)
Задание 28
Матрица AA
A размера 100×50100 \times 50
100×50. Какой размер у ATAA^T A
ATA? Какой размер у AATAA^T
AAT?
Показать решение 👇
Решение:
Дано: AA
A размера (100,50)(100, 50)
(100,50)
Часть 1: ATAA^T A
ATA
Шаг 1: Определяем размер ATA^T
AT
AA
A: (100,50)(100, 50)
(100,50)
ATA^T
AT: (50,100)(50, 100)
(50,100) (строки и столбцы поменялись)
Шаг 2: Проверяем возможность умножения AT×AA^T \times A
AT×A
ATA^T
AT: (50,100)(50, 100)
(50,100)
AA
A: (100,50)(100, 50)
(100,50)
Столбцы ATA^T
AT = 100 = строки AA
A ✅
Шаг 3: Вычисляем размер результата
(50,100)×(100,50)=(50,50)(50, 100) \times (100, 50) = (50, 50)
(50,100)×(100,50)=(50,50)
Вывод: ATAA^T A
ATA — квадратная матрица 50×5050 \times 50
50×50!
Часть 2: AATAA^T
AAT
Шаг 1: Проверяем умножение A×ATA \times A^T
A×AT
AA
A: (100,50)(100, 50)
(100,50)
ATA^T
AT: (50,100)(50, 100)
(50,100)
Столбцы AA
A = 50 = строки ATA^T
AT ✅
Шаг 2: Вычисляем размер
(100,50)×(50,100)=(100,100)(100, 50) \times (50, 100) = (100, 100)
(100,50)×(50,100)=(100,100)
Вывод: AATAA^T
AAT — квадратная матрица 100×100100 \times 100
100×100!
Важное наблюдение:
ATAA^T A
ATA: (50,50)(50, 50)
(50,50) — матрица признаков × признаков
AATAA^T
AAT: (100,100)(100, 100)
(100,100) — матрица примеров × примеров
В ML:
ATAA^T A
ATA используется для вычисления ковариаций признаков
AATAA^T
AAT используется в kernel methods (SVM)
Оба результата — симметричные матрицы!
Проверка: (ATA)T=AT(AT)T=ATA(A^T A)^T = A^T (A^T)^T = A^T A
(ATA)T=AT(AT)T=ATA ✅
Ответ:
ATAA^T A
ATA: (50,50)(50, 50)
(50,50)
AATAA^T
AAT: (100,100)(100, 100)
(100,100)
Задание 29
VGG-16 слой: Conv2D с 512 фильтрами 3×33 \times 3
3×3 на входе 512 каналов. Сколько параметров?
Показать решение 👇
Решение:
Шаг 1: Параметры Conv2D слоя
Формула: (K×F×F×C)+K(K \times F \times F \times C) + K
(K×F×F×C)+K
Где:
KK
K = количество фильтров (выходных каналов)
FF
F = размер фильтра
CC
C = входные каналы
+K+K
+K = bias для каждого фильтра
Шаг 2: Подставляем значения
K=512K = 512
K=512 (фильтров)
F=3F = 3
F=3 (размер фильтра)
C=512C = 512
C=512 (входных каналов)
Веса:
512×3×3×512=512×9×512512 \times 3 \times 3 \times 512 = 512 \times 9 \times 512
512×3×3×512=512×9×512
=512×4,608=2,359,296= 512 \times 4,608 = 2,359,296=512×4,608=2,359,296
Bias: 512
Всего:
2,359,296+512=2,359,8082,359,296 + 512 = 2,359,808
2,359,296+512=2,359,808
Шаг 3: В миллионах
≈2.36\approx 2.36
≈2.36 млн параметров в ОДНОМ слое!
Проверка:
pythonimport torch.nn as nn
conv = nn.Conv2d(512, 512, 3, bias=True)
params = sum(p.numel() for p in conv.parameters())
print(f"{params:,}") # 2,359,808
Контекст:
VGG-16 имеет несколько таких слоёв подряд:
Conv 512×512 (2.36 млн)
Conv 512×512 (2.36 млн)
Conv 512×512 (2.36 млн)
Только эти 3 слоя = 7 млн параметров!
Вся VGG-16: ~138 млн параметров
Ответ: 2,359,808 параметров (~2.36 млн)
Задание 30
Для dataset (1000,20)(1000, 20)
(1000,20) вычислите размер матрицы ковариаций. Сколько уникальных ковариаций нужно вычислить?
Показать решение 👇
Решение:
Шаг 1: Понимаем датасет
1000 примеров
20 признаков
Матрица XX
X: (1000,20)(1000, 20)
(1000,20)
Шаг 2: Размер матрицы ковариаций
Матрица ковариаций — это ковариации между всеми парами признаков.
Признаков: 20
Матрица ковариаций: (20,20)(20, 20)
(20,20)
$$\Sigma = \begin{pmatrix}
\text{Cov}(X_1, X_1) & \text{Cov}(X_1, X_2) & \cdots & \text{Cov}(X_1, X_{20}) \
\text{Cov}(X_2, X_1) & \text{Cov}(X_2, X_2) & \cdots & \text{Cov}(X_2, X_{20}) \
\vdots & \vdots & \ddots & \vdots \
\text{Cov}(X_{20}, X_1) & \text{Cov}(X_{20}, X_2) & \cdots & \text{Cov}(X_{20}, X_{20})
\end{pmatrix}$$
Шаг 3: Сколько уникальных ковариаций?
Всего элементов: 20×20=40020 \times 20 = 400
20×20=400
Но матрица симметрична: Cov(Xi,Xj)=Cov(Xj,Xi)\text{Cov}(X_i, X_j) = \text{Cov}(X_j, X_i)
Cov(Xi,Xj)=Cov(Xj,Xi)
Уникальные элементы:
Диагональ: 20 дисперсий (Var(Xi)=Cov(Xi,Xi)\text{Var}(X_i) = \text{Cov}(X_i, X_i)
Var(Xi)=Cov(Xi,Xi))
Верхний треугольник: 20×192=190\frac{20 \times 19}{2} = 190
220×19=190 ковариаций
Всего уникальных: 20+190=21020 + 190 = 210
20+190=210
Формула: Для nn
n признаков:
n(n+1)2=20×212=210\frac{n(n+1)}{2} = \frac{20 \times 21}{2} = 2102n(n+1)=220×21=210
Шаг 4: Код
pythonX = np.random.randn(1000, 20)
cov_matrix = np.cov(X.T)
print(cov_matrix.shape) # (20, 20)
Проверка симметрии
print(np.allclose(cov_matrix, cov_matrix.T)) # True
Уникальные элементы
unique = np.triu(cov_matrix).size - np.triu(cov_matrix, k=1).size
print(f"Уникальных: {cov_matrix.shape[0] * (cov_matrix.shape[0] + 1) // 2}") # 210
Ответ:
Размер матрицы: (20,20)(20, 20)
(20,20)
Уникальных ковариаций: 210 (20 дисперсий + 190 ковариаций)
Итоговое резюме: Что освоили за 3 части
Теоретическая база
✅ Определение матрицы — прямоугольная таблица чисел m×nm \times n
m×n
✅ Элементы — aija_{ij}
aij (строка ii
i, столбец jj
j)
✅ Shape — критичен для операций в нейросетях
Виды матриц
✅ Прямоугольная — датасеты, веса Dense
✅ Квадратная — ковариации, attention, confusion matrix
✅ Векторы — примеры, градиенты, bias
✅ Нулевая — инициализация, padding
✅ Единичная — AI=AAI = A
AI=A, обратные матрицы
✅ Диагональная — быстрые вычисления, Adam optimizer
✅ Симметричная — ковариации, kernel matrices
✅ Sparse — TF-IDF, one-hot, графы
ML применения
✅ Датасет: (m,n)(m, n)
(m,n) — примеры × признаки
✅ Веса Dense: (nout,nin)(n_{\text{out}}, n_{\text{in}})
(nout,nin)
✅ Embeddings: (V,d)(V, d)
(V,d) — словарь × размерность
✅ Attention: (n,n)(n, n)
(n,n) — квадратичная сложность
✅ Изображения: (H,W,C)(H, W, C)
(H,W,C) для RGB
✅ Батчи: (B,...)(B, ...)
(B,...) — первая размерность
✅ CNN фильтры: (K,C,F,F)(K, C, F, F)
(K,C,F,F) — независимо от размера входа
✅ Ковариации: (n,n)(n, n)
(n,n) — всегда симметричны
Практические навыки
✅ Считать параметры нейросетей
✅ Проверять совместимость размеров
✅ Работать с shape в PyTorch/NumPy
✅ Понимать sparse vs dense
✅ Создавать confusion matrix
✅ Вычислять ковариации
Финальный лайфхак 🔥
Главное правило работы с матрицами в ML:
ВСЕГДА проверяй shape!
90% ошибок в нейросетях — это несовместимые размеры матриц.
Привычка профи:
pythonprint(f"X: {X.shape}")
print(f"W: {W.shape}")
print(f"XW: {(X @ W).shape}") # Проверь ДО запуска!
Формула успеха:
Понимаешь матрицы → понимаешь линейную алгебру
Понимаешь линейную алгебру → понимаешь ML
Понимаешь ML → можешь создавать свои модели
Что дальше?
Следующие темы для изучения:
📚 Операции над матрицами:
Сложение, умножение
Транспонирование
Обратная матрица
📚 Разложения матриц:
SVD (Singular Value Decomposition)
Eigendecomposition
LU, QR разложения
📚 Применения в ML:
PCA (Principal Component Analysis)
SVD в рекомендациях
Batch Normalization
Градиентный спуск
💡 Последний совет: Матрицы — это не "страшная математика". Это твой главный инструмент как ML-инженера. Каждый раз, когда пишешь model.fit(X, y), помни: внутри происходят тысячи матричных операций. Теперь ты понимаешь, что именно!
Удачи в изучении ML! Ты теперь знаешь матрицы на глубоком уровне. 🚀
Понял тему? Закрепи в боте! 🚀
Попрактикуйся на задачах и получи персональные рекомендации от AI
💪 Начать тренировку