Матричные преобразования

Матрица — это машина, которая меняет форму пространства. Поймите, что она делает с каждой точкой, — и вы поймёте всё преобразование.

Тип: Практика Языки: Python, Julia Предварительные требования: Фаза 1, уроки 01–02 («Интуитивное понимание линейной алгебры», «Векторы, матрицы и операции») Время: ~75 минут

Цели обучения

• Построить матрицы поворота, масштабирования, сдвига и отражения и применить их к двумерным и трёхмерным точкам.
• Составлять несколько преобразований посредством умножения матриц и проверять, что порядок имеет значение.
• Вычислять собственные значения и собственные векторы матриц 2x2 из характеристического уравнения.
• Объяснить, почему собственные значения определяют направления PCA, устойчивость RNN и поведение спектральной кластеризации.

Проблема

Вы читаете о PCA и видите: «найдите собственные векторы ковариационной матрицы». Вы читаете об устойчивости моделей и видите: «проверьте, что модули всех собственных значений меньше 1». Вы читаете об аугментации данных и видите: «примените случайный поворот». Всё это не имеет смысла, пока вы не поймёте геометрически, что матрицы делают с пространством.

Матрицы — не просто таблицы чисел. Это пространственные машины. Матрица поворота вращает точки. Матрица масштабирования растягивает их. Матрица сдвига наклоняет их. Каждое преобразование данных, которое применяет нейронная сеть, — одна из этих операций или их композиция. Этот урок делает эти операции наглядными.

Концепция

Преобразования как матрицы

Каждое линейное преобразование в 2D можно записать матрицей 2x2. Матрица точно указывает, куда попадают базисные векторы [1, 0] и [0, 1]. Всё остальное следует из этого.

Поворот

Двумерный поворот на угол theta сохраняет расстояния и углы. Он перемещает каждую точку по дуге окружности.

В 3D вы вращаете вокруг оси. У каждой оси есть собственная матрица поворота:

Rz(theta) = | cos  -sin  0 |     Поворот вокруг оси z
            | sin   cos  0 |     (плоскость x-y вращается, z остаётся)
            |  0     0   1 |

Rx(theta) = | 1   0     0    |   Поворот вокруг оси x
            | 0  cos  -sin   |   (плоскость y-z вращается, x остаётся)
            | 0  sin   cos   |

Ry(theta) = |  cos  0  sin |     Поворот вокруг оси y
            |   0   1   0  |     (плоскость x-z вращается, y остаётся)
            | -sin  0  cos |

Масштабирование

Масштабирование независимо растягивает или сжимает вдоль каждой оси.

Сдвиг

Сдвиг наклоняет одну ось, сохраняя другую неподвижной. Он превращает прямоугольники в параллелограммы.

Матрицы сдвига:

• Shx = [[1, k], [0, 1]] сдвигает x на k * y.
• Shy = [[1, 0], [k, 1]] сдвигает y на k * x.

Отражение

Отражение зеркально отображает точки относительно оси или прямой.

Матрицы отражения:

• Отражение относительно оси y: [[-1, 0], [0, 1]].
• Отражение относительно оси x: [[1, 0], [0, -1]].

Композиция: цепочка преобразований

Применить преобразование A, а затем B — то же самое, что умножить их матрицы: result = B @ A @ point. Порядок имеет значение. Поворот с последующим масштабированием даёт иной результат, чем масштабирование с последующим поворотом.

Композиция: S @ R = [[0, -2], [0.5, 0]]

Композиция: R @ S = [[0, -0.5], [2, 0]]

Результаты различаются. Умножение матриц некоммутативно.

Собственные значения и собственные векторы

Большинство векторов меняют направление, когда на них действует матрица. Собственные векторы особенны: матрица только масштабирует их, но никогда не поворачивает. Коэффициент масштабирования — это собственное значение.

A @ v = lambda * v

v — собственный вектор (направление, которое сохраняется)
lambda — собственное значение (насколько оно растягивает)

Пример: A = | 2  1 |
              | 1  2 |

Собственный вектор [1, 1] с собственным значением 3:
  A @ [1,1] = [3, 3] = 3 * [1, 1]     (то же направление, масштабирован в 3 раза)

Собственный вектор [1, -1] с собственным значением 1:
  A @ [1,-1] = [1, -1] = 1 * [1, -1]  (то же направление, без изменений)

Матрица растягивает пространство в 3 раза вдоль [1, 1] и оставляет [1, -1] без изменений. Любое другое направление — смесь этих двух.

Спектральное разложение

Если у матрицы есть n линейно независимых собственных векторов, её можно разложить:

A = V @ D @ V^(-1)

V = матрица, чьи столбцы — собственные векторы
D = диагональная матрица собственных значений
V^(-1) = обратная к V матрица

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

Почему важны собственные значения

PCA. Собственные векторы ковариационной матрицы — главные компоненты. Собственные значения показывают, какую долю дисперсии захватывает каждый компонент. Отсортируйте по собственному значению, оставьте k наибольших — и получите снижение размерности.

Устойчивость. В рекуррентных сетях и динамических системах собственные значения с модулем > 1 заставляют выходы взрываться. Модуль < 1 заставляет их затухать. Это проблема исчезающих/взрывающихся градиентов, сформулированная одним предложением.

Спектральные методы. Графовые нейронные сети используют собственные значения матрицы смежности. Спектральная кластеризация использует собственные значения лапласиана. Собственные векторы раскрывают структуру графа.

Определитель как коэффициент масштабирования объёма

Определитель матрицы преобразования показывает, во сколько раз она масштабирует площадь (2D) или объём (3D).

det = 1:   площадь сохраняется (поворот)
det = 2:   площадь удваивается
det = 0:   пространство сжато до меньшей размерности (вырожденная матрица)
det = -1:  площадь сохраняется, но ориентация перевёрнута (отражение)

| det(Rotation) | = 1        (всегда)
| det(Scale sx, sy) | = sx * sy
| det(Shear) | = 1           (площадь сохраняется)
| det(Reflection) | = -1     (ориентация перевёрнута)

matrix-transform

Соберите это

Шаг 1: Матрицы преобразований с нуля (Python)

import math

def rotation_2d(theta):
    c, s = math.cos(theta), math.sin(theta)
    return [[c, -s], [s, c]]

def scaling_2d(sx, sy):
    return [[sx, 0], [0, sy]]

def shearing_2d(kx, ky):
    return [[1, kx], [ky, 1]]

def reflection_x():
    return [[1, 0], [0, -1]]

def reflection_y():
    return [[-1, 0], [0, 1]]

def mat_vec_mul(matrix, vector):
    return [
        sum(matrix[i][j] * vector[j] for j in range(len(vector)))
        for i in range(len(matrix))
    ]

def mat_mul(a, b):
    rows_a, cols_b = len(a), len(b[0])
    cols_a = len(a[0])
    return [
        [sum(a[i][k] * b[k][j] for k in range(cols_a)) for j in range(cols_b)]
        for i in range(rows_a)
    ]

point = [1.0, 0.0]
angle = math.pi / 4

rotated = mat_vec_mul(rotation_2d(angle), point)
print(f"Rotate (1,0) by 45 deg: ({rotated[0]:.4f}, {rotated[1]:.4f})")

scaled = mat_vec_mul(scaling_2d(2, 3), [1.0, 1.0])
print(f"Scale (1,1) by (2,3): ({scaled[0]:.1f}, {scaled[1]:.1f})")

sheared = mat_vec_mul(shearing_2d(1, 0), [1.0, 1.0])
print(f"Shear (1,1) kx=1: ({sheared[0]:.1f}, {sheared[1]:.1f})")

reflected = mat_vec_mul(reflection_y(), [2.0, 1.0])
print(f"Reflect (2,1) across y: ({reflected[0]:.1f}, {reflected[1]:.1f})")

Шаг 2: Композиция преобразований

R = rotation_2d(math.pi / 2)
S = scaling_2d(2, 0.5)

rotate_then_scale = mat_mul(S, R)
scale_then_rotate = mat_mul(R, S)

point = [1.0, 0.0]
result1 = mat_vec_mul(rotate_then_scale, point)
result2 = mat_vec_mul(scale_then_rotate, point)

print(f"Rotate 90 then scale: ({result1[0]:.2f}, {result1[1]:.2f})")
print(f"Scale then rotate 90: ({result2[0]:.2f}, {result2[1]:.2f})")
print(f"Same? {result1 == result2}")

Шаг 3: Собственные значения с нуля (2x2)

Для матрицы 2x2 [[a, b], [c, d]] собственные значения решают характеристическое уравнение: lambda^2 - (a+d)*lambda + (ad - bc) = 0.

def eigenvalues_2x2(matrix):
    a, b = matrix[0]
    c, d = matrix[1]
    trace = a + d
    det = a * d - b * c
    discriminant = trace ** 2 - 4 * det
    if discriminant < 0:
        real = trace / 2
        imag = (-discriminant) ** 0.5 / 2
        return (complex(real, imag), complex(real, -imag))
    sqrt_disc = discriminant ** 0.5
    return ((trace + sqrt_disc) / 2, (trace - sqrt_disc) / 2)

def eigenvector_2x2(matrix, eigenvalue):
    a, b = matrix[0]
    c, d = matrix[1]
    if abs(b) > 1e-10:
        v = [b, eigenvalue - a]
    elif abs(c) > 1e-10:
        v = [eigenvalue - d, c]
    else:
        if abs(a - eigenvalue) < 1e-10:
            v = [1, 0]
        else:
            v = [0, 1]
    mag = (v[0] ** 2 + v[1] ** 2) ** 0.5
    return [v[0] / mag, v[1] / mag]

A = [[2, 1], [1, 2]]
vals = eigenvalues_2x2(A)
print(f"Matrix: {A}")
print(f"Eigenvalues: {vals[0]:.4f}, {vals[1]:.4f}")

for val in vals:
    vec = eigenvector_2x2(A, val)
    result = mat_vec_mul(A, vec)
    scaled = [val * vec[0], val * vec[1]]
    print(f"  lambda={val:.1f}, v={[round(x,4) for x in vec]}")
    print(f"    A@v = {[round(x,4) for x in result]}")
    print(f"    l*v = {[round(x,4) for x in scaled]}")

Шаг 4: Определитель как коэффициент масштабирования объёма

def det_2x2(matrix):
    return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0]

print(f"det(rotation 45) = {det_2x2(rotation_2d(math.pi/4)):.4f}")
print(f"det(scale 2,3)   = {det_2x2(scaling_2d(2, 3)):.1f}")
print(f"det(shear kx=1)  = {det_2x2(shearing_2d(1, 0)):.1f}")
print(f"det(reflect y)   = {det_2x2(reflection_y()):.1f}")

singular = [[1, 2], [2, 4]]
print(f"det(singular)     = {det_2x2(singular):.1f}")
print("Singular: columns are proportional, space collapses to a line.")

Используйте это

NumPy выполняет всё это оптимизированными процедурами.

import numpy as np

theta = np.pi / 4
R = np.array([[np.cos(theta), -np.sin(theta)],
              [np.sin(theta),  np.cos(theta)]])

point = np.array([1.0, 0.0])
print(f"Rotate (1,0) by 45 deg: {R @ point}")

S = np.diag([2.0, 3.0])
composed = S @ R
print(f"Scale(2,3) after Rotate(45): {composed @ point}")

A = np.array([[2, 1], [1, 2]], dtype=float)
eigenvalues, eigenvectors = np.linalg.eig(A)
print(f"\nEigenvalues: {eigenvalues}")
print(f"Eigenvectors (columns):\n{eigenvectors}")

for i in range(len(eigenvalues)):
    v = eigenvectors[:, i]
    lam = eigenvalues[i]
    print(f"  A @ v{i} = {A @ v}, lambda * v{i} = {lam * v}")

print(f"\ndet(R) = {np.linalg.det(R):.4f}")
print(f"det(S) = {np.linalg.det(S):.1f}")

B = np.array([[3, 1], [0, 2]], dtype=float)
vals, vecs = np.linalg.eig(B)
D = np.diag(vals)
V = vecs
reconstructed = V @ D @ np.linalg.inv(V)
print(f"\nEigendecomposition A = V @ D @ V^-1:")
print(f"Original:\n{B}")
print(f"Reconstructed:\n{reconstructed}")

Трёхмерные повороты с NumPy

def rotation_3d_z(theta):
    c, s = np.cos(theta), np.sin(theta)
    return np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]])

def rotation_3d_x(theta):
    c, s = np.cos(theta), np.sin(theta)
    return np.array([[1, 0, 0], [0, c, -s], [0, s, c]])

point_3d = np.array([1.0, 0.0, 0.0])
rotated_z = rotation_3d_z(np.pi / 2) @ point_3d
rotated_x = rotation_3d_x(np.pi / 2) @ point_3d

print(f"\n3D point: {point_3d}")
print(f"Rotate 90 around z: {np.round(rotated_z, 4)}")
print(f"Rotate 90 around x: {np.round(rotated_x, 4)}")

Внедрите это

Этот урок создаёт геометрическую основу для PCA (фаза 2) и анализа весов нейронных сетей. Код для собственных значений и собственных векторов, созданный здесь, использует тот же алгоритм, что лежит в основе снижения размерности, спектральной кластеризации и анализа устойчивости в производственных ML-системах.

Упражнения

1. Примените поворот, масштабирование и сдвиг к единичному квадрату (углы: [0,0], [1,0], [1,1], [0,1]). Выведите преобразованные углы для каждого случая. Убедитесь, что поворот сохраняет расстояния между углами.

2. Найдите вручную собственные значения матрицы [[4, 2], [1, 3]], используя характеристическое уравнение. Затем проверьте ответ своей функцией, реализованной с нуля, и с помощью NumPy.

3. Создайте композицию из трёх преобразований (поворот на 30 градусов, масштабирование на [1.5, 0.8], сдвиг с kx=0.3) и примените её к 8 точкам, расположенным по окружности. Выведите координаты до и после. Вычислите определитель составной матрицы и убедитесь, что он равен произведению определителей отдельных матриц.

Ключевые термины

Термин	Как обычно говорят	Что это на самом деле означает
Матрица поворота	«Вращает объекты»	Ортогональная матрица, перемещающая точки по дугам окружностей с сохранением расстояний и углов. Её определитель всегда равен 1.
Матрица масштабирования	«Увеличивает объекты»	Диагональная матрица, которая независимо растягивает или сжимает вдоль каждой оси. Её определитель равен произведению коэффициентов масштабирования.
Матрица сдвига	«Наклоняет объекты»	Матрица, сдвигающая одну координату пропорционально другой и превращающая прямоугольники в параллелограммы. Её определитель равен 1.
Отражение	«Зеркально отображает объекты»	Матрица, отражающая пространство относительно оси или плоскости. Её определитель равен -1.
Композиция	«Делает две вещи»	Умножение матриц преобразований для цепочки операций. Порядок важен: B @ A означает сначала применить A, затем B.
Собственный вектор	«Особое направление»	Направление, которое матрица только масштабирует, но никогда не поворачивает. Отпечаток преобразования.
Собственное значение	«Насколько оно растягивает»	Скалярный множитель, на который матрица масштабирует собственный вектор. Может быть отрицательным (переворот) или комплексным (поворот).
Спектральное разложение	«Разобрать матрицу на части»	Запись матрицы как V @ D @ V^(-1), разделяющая её на фундаментальные направления масштабирования и их величины.
Определитель	«Одно число из матрицы»	Коэффициент, на который преобразование масштабирует площадь (2D) или объём (3D). Ноль означает, что преобразование необратимо.
Характеристическое уравнение	«Откуда берутся собственные значения»	det(A - lambda * I) = 0. Многочлен, корнями которого являются собственные значения.

Дополнительные материалы

• 3Blue1Brown: Linear Transformations — визуальная интуиция о том, как матрицы меняют форму пространства.
• 3Blue1Brown: Eigenvectors and Eigenvalues — лучшее визуальное объяснение геометрического смысла собственных векторов.
• MIT 18.06 Lecture 21: Eigenvalues and Eigenvectors — классическое изложение Гилберта Стрэнга.

---

Источник: Matrix Transformations — оригинал Навигация: назад: 01.02 — Векторы, матрицы и операции · Фаза 1 — Математические основы · Полный каталог · далее: 01.04 — Математический анализ для ML.