0Pricing
Pandas & NumPy Academy · Урок

Определители, обратные матрицы и транспонирование

Вычисляйте определители матриц с помощью np.linalg.det, обратные матрицы — с помощью np.linalg.inv, а транспонированные матрицы — с помощью .T

«Определители, обратные матрицы и транспонирование» — бесплатный урок Pandas & NumPy Academy на CoddyKit. Это урок 2 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения Pandas & NumPy Academy, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс Pandas & NumPy Academy содержит 4 уроков всего.

Транспонированная матрица

Транспонирование матрицы отражает её относительно диагонали: строки становятся столбцами, а столбцы — строками. Если A имеет форму (m, n), то A.T имеет форму (n, m). Транспонирование встречается повсюду в линейной алгебре: при вычислении ковариационных матриц, реализации обратного распространения градиента и переходе между соглашениями о векторах-строках и векторах-столбцах. NumPy обращается к транспонированной матрице через атрибут .T: копия не создаётся, это лишь представление с изменёнными шагами.

import numpy as np

A = np.array([[1, 2, 3],
              [4, 5, 6]])
print('A shape:', A.shape)       # (2, 3)
print('A.T shape:', A.T.shape)   # (3, 2)
print(A.T)

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

Часто используется выражение A.T @ A, создающее симметричную квадратную матрицу, которая встречается в регрессии методом наименьших квадратов, PCA и нормальных уравнениях. Если A имеет форму (n, p), то A.T @ A имеет форму (p, p). Результат всегда симметричен, поскольку (A.T @ A)[i,j] == (A.T @ A)[j,i]. Многие численные решатели используют это свойство для повышения эффективности.

import numpy as np

A = np.array([[1.0, 2.0],
              [3.0, 4.0],
              [5.0, 6.0]])  # shape (3, 2)

ATA = A.T @ A   # shape (2, 2), symmetric
print('A.T @ A:')
print(ATA)
print('Is symmetric:', np.allclose(ATA, ATA.T))

Определитель: что он означает

Определитель квадратной матрицы — это скалярное значение, содержащее геометрическую информацию: оно показывает, во сколько раз матрица изменяет площади (в двумерном случае) или объёмы (в пространствах большей размерности). Нулевой определитель означает, что матрица вырождена: она отображает пространство в подпространство меньшей размерности и не имеет обратной матрицы. Ненулевой определитель гарантирует, что матрица обратима. NumPy вычисляет его с помощью np.linalg.det().

import numpy as np

# Non-singular matrix
A = np.array([[3.0, 1.0],
              [2.0, 4.0]])
print('det(A):', np.linalg.det(A))   # 3*4 - 1*2 = 10

# Singular matrix (row 2 = 2 * row 1)
B = np.array([[1.0, 2.0],
              [2.0, 4.0]])
print('det(B):', np.linalg.det(B))   # ~0

Вычисление обратной матрицы с помощью np.linalg.inv()

Обратная матрица матрицы A, обозначаемая как A⁻¹, удовлетворяет условию A @ A⁻¹ = I, где I — единичная матрица. Обратные матрицы существуют только для квадратных невырожденных матриц. np.linalg.inv(A) вычисляет обратную матрицу численно. На практике обратные матрицы следует вычислять явно крайне редко, поскольку это численно неустойчиво; вместо этого для решения систем уравнений используйте np.linalg.solve(). Однако концептуальное понимание обратных матриц крайне важно.

import numpy as np

A = np.array([[3.0, 1.0],
              [2.0, 4.0]])

A_inv = np.linalg.inv(A)
print('Inverse:')
print(A_inv)

# Verify: A @ A_inv should be identity
I = A @ A_inv
print('A @ A_inv (should be I):')
print(np.round(I, 10))

Численная неустойчивость прямого обращения матрицы

Вычисление обратной матрицы с последующим умножением приводит к накоплению погрешностей вычислений с плавающей точкой. Например, решение с помощью A_inv @ b менее точно, чем непосредственный вызов np.linalg.solve(A, b). Хорошо обусловленная матрица (с определителем, далёким от нуля) менее чувствительна к этим ошибкам. Число обусловленности (np.linalg.cond(A)) показывает, насколько матрица близка к вырожденной: большие числа обусловленности указывают на численные проблемы.

import numpy as np

A = np.array([[1.0, 2.0],
              [1.0001, 2.0]])
print('Condition number:', np.linalg.cond(A))
# Very high condition number -> near-singular, unstable inversion

b = np.array([3.0, 3.0001])
# Prefer solve over inv @ b
print('Solution via solve:', np.linalg.solve(A, b))

Ортогональные матрицы и их транспонированные матрицы

Ортогональные матрицы — это особый класс матриц, для которых выполняется A.T @ A = I. Это означает, что транспонированная матрица является обратной, поэтому обращение ортогональных матриц требует крайне мало вычислений. Матрицы вращения и множитель Q в QR-разложении являются ортогональными. Столбцы ортогональной матрицы образуют ортонормированный базис: длина каждого столбца равна единице, и он перпендикулярен всем остальным столбцам.

import numpy as np

# 90-degree rotation matrix is orthogonal
theta = np.pi / 2
R = np.array([[np.cos(theta), -np.sin(theta)],
              [np.sin(theta),  np.cos(theta)]])

print('R.T @ R (should be identity):')
print(np.round(R.T @ R, 10))
print('Is orthogonal:', np.allclose(R.T @ R, np.eye(2)))

Псевдообратная матрица для неквадратных матриц

Обычная обратная матрица существует только для квадратных матриц, но псевдообратная матрица Мура — Пенроуза обобщает обращение на любую матрицу. np.linalg.pinv(A) вычисляет её с помощью SVD. Она лежит в основе метода наименьших квадратов для переопределённых систем (уравнений больше, чем неизвестных), то есть именно того, что решает линейная регрессия. Если A квадратная и обратимая, pinv(A) равна inv(A).

import numpy as np

# Over-determined system: 3 equations, 2 unknowns
A = np.array([[1.0, 1.0],
              [1.0, 2.0],
              [1.0, 3.0]])
b = np.array([2.0, 3.0, 5.0])

# Least-squares solution using pseudo-inverse
x = np.linalg.pinv(A) @ b
print('Best-fit solution:', x)
# Or use lstsq directly
x2, _, _, _ = np.linalg.lstsq(A, b, rcond=None)
print('lstsq solution:', x2)

Знак определителя и масштабирование объёма

Знак определителя показывает, сохраняет ли преобразование ориентацию или меняет её на противоположную. Положительный определитель означает, что ориентация сохраняется (как при вращении); отрицательный — что ориентация меняется на противоположную (как при отражении). Абсолютное значение определителя задаёт коэффициент масштабирования объёма. Для матрицы 2×2 [[a,b],[c,d]] выполняется det = a*d - b*c. NumPy эффективно обрабатывает квадратные матрицы произвольного размера.

import numpy as np

# Identity: det = 1 (no scaling, no flip)
I = np.eye(3)
print('det(I):', np.linalg.det(I))    # 1.0

# Scaling by 2 in all directions: det = 8 = 2^3
S = 2 * np.eye(3)
print('det(2I):', np.linalg.det(S))   # 8.0

# Reflection: det = -1
F = np.array([[-1.0, 0.0],
              [ 0.0, 1.0]])
print('det(reflection):', np.linalg.det(F))

Использование np.linalg.slogdet() для повышения устойчивости

Для больших матриц определитель может выйти за допустимый диапазон или стать равным нулю из-за потери точности, даже если матрица невырожденная. np.linalg.slogdet(A) возвращает (sign, log_abs_det) — знак и натуральный логарифм абсолютного значения определителя, что позволяет избежать численного переполнения. Этот подход широко используется в вероятностных моделях (например, при работе с гауссовскими правдоподобиями), где вычисления выполняются в логарифмическом пространстве, чтобы значения оставались управляемыми.

import numpy as np

A = np.random.rand(100, 100)

# Direct det might underflow for large matrices
sign, logdet = np.linalg.slogdet(A)
print('Sign:', sign)
print('Log|det|:', logdet)
print('Actual det (may be ~0 due to float):', np.linalg.det(A))
print('Reconstructed |det|:', np.exp(logdet))

На практике: решение системы 2×2 вручную и с помощью NumPy

Для матрицы 2×2 [[a, b], [c, d]] обратная матрица имеет вид (1/det) * [[d, -b], [-c, a]], где det = ad - bc. Знание этой формулы помогает вручную проверить результат NumPy на простом примере. Для матриц большего размера аналитическое вычисление обратной матрицы непрактично — именно поэтому мы используем np.linalg.inv(). Всегда проверяйте численные результаты с помощью np.allclose(A @ A_inv, np.eye(n)).

import numpy as np

a, b, c, d = 3.0, 1.0, 2.0, 4.0
A = np.array([[a, b], [c, d]])
det = a*d - b*c

# Manual inverse
A_inv_manual = (1/det) * np.array([[d, -b], [-c, a]])
print('Manual inv:')
print(A_inv_manual)

# NumPy inverse
print('np.linalg.inv:')
print(np.linalg.inv(A))
print('Match:', np.allclose(A_inv_manual, np.linalg.inv(A)))

Сочетание транспонирования и обращения в вычислительных цепочках

Распространённый приём линейной алгебры сочетает транспонирование и обращение: вычисление (A.T @ A)⁻¹ @ A.T даёт проекционную матрицу, используемую в обычном методе наименьших квадратов. В NumPy это можно записать как np.linalg.inv(A.T @ A) @ A.T, но, как и прежде, с точки зрения численной устойчивости предпочтительнее использовать np.linalg.lstsq. Понимание этого базового приёма помогает разобраться в работе решателя и находить ошибки, когда матрицы близки к вырожденным.

import numpy as np

# Design matrix for simple linear regression (with bias)
X = np.column_stack([np.ones(5), np.array([1., 2., 3., 4., 5.])])
y = np.array([2.1, 3.9, 6.2, 8.1, 9.8])

# OLS via normal equations: beta = (X.T @ X)^-1 @ X.T @ y
beta = np.linalg.inv(X.T @ X) @ X.T @ y
print('Coefficients (intercept, slope):', np.round(beta, 3))

# Verify with lstsq
beta2, _, _, _ = np.linalg.lstsq(X, y, rcond=None)
print('lstsq result:', np.round(beta2, 3))

Быстрая проверка

Проверьте своё понимание концепций анализа данных из этого урока.

Итоги урока

В этом уроке вы узнали, что A.T — это транспонированная матрица, в которой строки и столбцы меняются местами; np.linalg.inv() вычисляет обратную матрицу, но напрямую эту функцию следует использовать редко (предпочтительнее solve или lstsq); а np.linalg.det() возвращает определитель, равный нулю для вырожденных матриц. Далее мы рассмотрим непосредственное решение линейных систем с помощью np.linalg.solve.

Часто задаваемые вопросы

Урок «Определители, обратные матрицы и транспонирование» бесплатный?

Да — полный текст урока «Определители, обратные матрицы и транспонирование» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс Pandas & NumPy Academy, подпишись на CoddyKit PRO. Курс Pandas & NumPy Academy содержит 4 уроков всего.

Чему я научусь в уроке «Определители, обратные матрицы и транспонирование»?

Вычисляйте определители матриц с помощью np.linalg.det, обратные матрицы — с помощью np.linalg.inv, а транспонированные матрицы — с помощью .T Ты практикуешь Pandas & NumPy Academy с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать Pandas & NumPy Academy?

Предыдущий опыт не требуется. Pandas & NumPy Academy на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 2 из 4.

Сколько времени занимает урок «Определители, обратные матрицы и транспонирование»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке Pandas & NumPy Academy?

Да. Каждый урок Pandas & NumPy Academy включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

  1. Умножение матриц с помощью np.matmul и @
  2. Определители, обратные матрицы и транспонирование
  3. Решение систем линейных уравнений
  4. Собственные значения и обзор SVD
← Назад к Pandas & NumPy Academy