Numpy.linalg.inv: примеры (PYTHON)

Функция numpy.linalg.inv и вычисление обратных матриц
Раздел: NumPy, Линейная алгебра
numpy.linalg.inv(a: ndarray): ndarray
типовые примерыnumpy.linalg.inv на php, c#, sql, javanumpy.linalg.inv изменения pythonпримеры расширенные

Функция numpy.linalg.inv

numpy.linalg.inv(a)

Эта функция вычисляет мультипликативную обратную матрицу для квадратной матрицы a. Обратная матрица A-1 существует только для квадратных невырожденных (с ненулевым определителем) матриц и удовлетворяет условию: A @ A-1 = A-1 @ A = I, где I - единичная матрица.

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

Аргументы:

  • a (array_like): Входная квадратная матрица, для которой требуется найти обратную. Должна быть двумерной и иметь форму (M, M).

Возвращаемое значение:

  • inv (ndarray): Обратная матрица для a. Форма совпадает с формой входной матрицы - (M, M).

Примеры использования

Базовый пример с вещественной матрицей 2x2:

import numpy as np

A = np.array([[4, 7],
              [2, 6]])
A_inv = np.linalg.inv(A)
print(A_inv)
[[ 0.6 -0.7]
 [-0.2  0.4]]

Проверка свойства обратной матрицы:

print(A @ A_inv)
[[1.00000000e+00 1.11022302e-16]
 [0.00000000e+00 1.00000000e+00]]

Работа с комплексными числами:

B = np.array([[1+2j, 3+1j],
              [0-1j, 2+0j]])
B_inv = np.linalg.inv(B)
print(B_inv)
[[ 0.4-0.8j -0.2+0.6j]
 [ 0. +0.2j  0.4+0.2j]]

Похожие функции в Python

  • numpy.linalg.pinv: Вычисляет псевдообратную (Мура-Пенроуза) матрицу. Может применяться к неквадратным и вырожденным матрицам. Используется, когда обычная обратная матрица не существует или требуется более устойчивое решение.
  • numpy.linalg.solve: Решает систему линейных уравнений A @ x = b. Для однократного решения системы метод solve предпочтительнее явного вычисления обратной матрицы, так как он численно устойчивее и эффективнее.
  • scipy.linalg.inv: Аналогичная функция из SciPy. Может предлагать дополнительные параметры и алгоритмы, особенно для больших или разреженных матриц.

Аналоги функции в других языках

JavaScript (math.js):

const math = require('mathjs');
const A = [[4, 7], [2, 6]];
const A_inv = math.inv(A);
console.log(A_inv);
[[0.6, -0.7], [-0.2, 0.4]]

Java (Apache Commons Math):

import org.apache.commons.math3.linear.*;

RealMatrix A = MatrixUtils.createRealMatrix(
        new double[][]{{4, 7}, {2, 6}});
RealMatrix A_inv = new LUDecomposition(A).getSolver().getInverse();
System.out.println(Arrays.deepToString(A_inv.getData()));

PHP:

// Используя pear Math_Matrix
require_once 'Math/Matrix.php';
$A = new Math_Matrix([[4, 7], [2, 6]]);
$A_inv = $A->inverse();
echo $A_inv->toString();

C# (MathNet.Numerics):

using MathNet.Numerics.LinearAlgebra;

var A = Matrix.Build.DenseOfArray(new double[,] {{4, 7}, {2, 6}});
var A_inv = A.Inverse();
Console.WriteLine(A_inv);

Типичные ошибки

LinAlgError при вырожденной матрице: Функция вызывает исключение, если матрица сингулярна (её определитель равен нулю).

import numpy as np

C = np.array([[1, 2],
              [2, 4]])  # Вторая строка равна удвоенной первой
try:
    C_inv = np.linalg.inv(C)
except np.linalg.LinAlgError as e:
    print(f"Ошибка: {e}")
Ошибка: Singular matrix

Ошибка при неквадратной матрице: Функция ожидает квадратную матрицу.

D = np.array([[1, 2, 3],
              [4, 5, 6]])
try:
    D_inv = np.linalg.inv(D)
except np.linalg.LinAlgError as e:
    print(f"Ошибка: {e}")
Ошибка: Last 2 dimensions of the array must be square

Изменения в последних версиях

В NumPy 1.22.0 для функции numpy.linalg.inv появилась экспериментальная поддержка массива подписей. Это позволяет векторизованно вычислять обратные матрицы для стека (batch) матриц, что повышает производительность. Например, если входной массив имеет форму (..., M, M), то результат будет иметь форму (..., M, M).

# Работа с несколькими матрицами
A_batch = np.array([[[1, 2], [3, 4]],
                    [[5, 6], [7, 8]]])
inverses = np.linalg.inv(A_batch)
print(inverses.shape)
print(inverses[0])
(2, 2, 2)
[[-2.   1. ]
 [ 1.5 -0.5]]

Расширенные примеры

Вычисление обратной матрицы с использованием метода Гаусса через LU-разложение (эквивалент внутренней реализации inv):

Пример python
import numpy as np
from scipy.linalg import lu_factor, lu_solve

A = np.array([[4, 7],
              [2, 6]], dtype=float)
lu, piv = lu_factor(A)
# Обратная матрица находится решением A * X = I
I = np.eye(A.shape[0])
A_inv_lu = lu_solve((lu, piv), I)
print("Обратная через LU:\n", A_inv_lu)
print("Прямой вызов inv:\n", np.linalg.inv(A))
Обратная через LU:
 [[ 0.6 -0.7]
 [-0.2  0.4]]
Прямой вызов inv:
 [[ 0.6 -0.7]
 [-0.2  0.4]]

Обращение блочно-диагональной матрицы:

Пример python
from scipy.linalg import block_diag

B1 = np.array([[1, 2], [3, 4]])
B2 = np.array([[5, 6, 7], [8, 9, 10], [11, 12, 13]])
B = block_diag(B1, B2)
B_inv = np.linalg.inv(B)
# Обратная блочно-диагональной матрицы - блочно-диагональная из обратных блоков
expected = block_diag(np.linalg.inv(B1), np.linalg.inv(B2))
print(np.allclose(B_inv, expected))
True

Вычисление обратной матрицы с малой добавкой для улучшения обусловленности (регуляризация Тихонова):

Пример python
# Матрица близка к вырожденной
C = np.array([[1.001, 1],
              [1, 1.001]])
# Прямое обращение
C_inv_direct = np.linalg.inv(C)
# Регуляризация
lambda_reg = 1e-5
C_reg = C + lambda_reg * np.eye(2)
C_inv_reg = np.linalg.inv(C_reg)
print("Прямая обратная:\n", C_inv_direct)
print("\nРегуляризованная обратная:\n", C_inv_reg)

питон numpy.linalg.inv function comments

En
Numpy.linalg.inv Compute matrix inverse