Методы обертывания матрицы

Для того чтобы обернуть матрицу Гильберта $10 \times 10$ и при этом обеспечить относительную погрешность не более 5%, лучше использовать численные методы решения, такие как LU-разложение с регуляризацией или метод сингулярного разложения (SVD). Это связано с тем, что матрицы Гильберта очень плохо обусловлены, что делает их неустойчивыми к прямым методам инверсии.

Общие шаги:

1. Создание матрицы Гильберта: Для создания матрицы $H$ можно воспользоваться специальными функциями в библиотеках вроде NumPy.

   python
   Copy code
   import numpy as np
   from scipy.linalg import hilbert
   
   H = hilbert(10)  # Создание матрицы Гильберта 10x10
   

2. Выбор метода решения:

   • Метод LU-разложения с регуляризацией: Применение малой регуляризации может помочь стабилизировать решение. Например, можно использовать регуляризацию Тихонова.
   • Метод SVD: Этот метод позволяет отфильтровать малые сингулярные числа, которые могут сильно влиять на точность.

3. Проверка погрешности:

   • Решите систему $H \cdot x = b$, где $b$ — вектор правой части.
   • Вычислите относительную погрешность:
   $$\text{Relative Error} = \frac{\| H \cdot x - b \|}{\| b \|}$$

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

Вот пример кода на Python, который использует сингулярное разложение (SVD) для решения системы с матрицей Гильберта $10 \times 10$ и вычисления относительной погрешности:

python
Copy code
import numpy as np
from scipy.linalg import hilbert, svd

# Создаем матрицу Гильберта 10x10
H = hilbert(10)

# Генерируем случайный вектор правой части
b = np.random.rand(10)

# Выполняем SVD-разложение матрицы H
U, s, Vt = svd(H)

# Инвертируем диагональную матрицу с пороговым значением для фильтрации малых сингулярных чисел
threshold = 1e-10  # порог для чисел, близких к нулю
s_inv = np.array([1/x if x > threshold else 0 for x in s])

# Находим решение x
x_svd = Vt.T @ np.diag(s_inv) @ U.T @ b

# Вычисляем относительную погрешность
relative_error = np.linalg.norm(H @ x_svd - b) / np.linalg.norm(b)

print(f"Решение x: {x_svd}")
print(f"Относительная погрешность: {relative_error * 100:.2f}%")

Этот код:

1. Создает матрицу Гильберта и вектор правой части.
2. Применяет SVD-разложение для матрицы Гильберта.
3. Фильтрует малые сингулярные числа для улучшения устойчивости решения.
4. Вычисляет относительную погрешность и выводит результат.

Если относительная погрешность окажется больше 5%, можно корректировать порог фильтрации малых сингулярных чисел, например, изменить threshold.

Для того чтобы гарантировать относительную погрешность не более 5%, можно использовать регуляризацию Тихонова (также известную как Ridge Regression). Этот метод добавляет к диагональным элементам матрицы небольшую регуляризационную составляющую, которая помогает улучшить устойчивость к плохо обусловленным задачам, таким как инверсия матрицы Гильберта.

Ниже пример кода с использованием регуляризации Тихонова:

python
Copy code
import numpy as np
from scipy.linalg import hilbert

# Создаем матрицу Гильберта 10x10
H = hilbert(10)

# Генерируем случайный вектор правой части
b = np.random.rand(10)

# Регуляризационный параметр (лямбда) для Тихонова
lambda_reg = 1e-2  # Подберите так, чтобы погрешность не превышала 5%

# Решаем систему с регуляризацией Тихонова
I = np.eye(H.shape[0])  # Единичная матрица
H_reg = H.T @ H + lambda_reg * I  # Добавляем регуляризацию
x_reg = np.linalg.solve(H_reg, H.T @ b)  # Решаем регуляризованную систему

# Вычисляем относительную погрешность
relative_error = np.linalg.norm(H @ x_reg - b) / np.linalg.norm(b)

print(f"Решение x: {x_reg}")
print(f"Относительная погрешность: {relative_error * 100:.2f}%")

Объяснение:

1. Регуляризация Тихонова: К матрице $H^T H$ добавляется $\lambda I$, где $\lambda$ — регуляризационный параметр. Его нужно подбирать так, чтобы относительная погрешность была не более 5%.
2. Подбор параметра: Параметр lambda_reg можно варьировать. Начальное значение $1e-2$ может быть подходящим, но для точной подгонки лучше попробовать разные значения.

Этот метод гарантирует уменьшение влияния плохой обусловленности матрицы Гильберта и помогает достичь требуемой точности.

Вот законченный код, который автоматически подбирает регуляризационный параметр $\lambda$, чтобы относительная погрешность не превышала 5%. Этот код использует цикл для поиска подходящего значения $\lambda$:

python
Copy code
import numpy as np
from scipy.linalg import hilbert

# Создаем матрицу Гильберта 10x10
H = hilbert(10)

# Генерируем случайный вектор правой части
b = np.random.rand(10)

# Параметры
target_error = 0.05  # Целевая погрешность (5%)
lambda_min = 1e-10   # Минимальное значение регуляризационного параметра
lambda_max = 1e-1    # Максимальное значение регуляризационного параметра
tolerance = 1e-4     # Точность поиска
max_iterations = 100  # Максимальное количество итераций

def compute_relative_error(H, x, b):
    return np.linalg.norm(H @ x - b) / np.linalg.norm(b)

def solve_with_tikhonov(H, b, lambda_reg):
    I = np.eye(H.shape[0])
    H_reg = H.T @ H + lambda_reg * I
    return np.linalg.solve(H_reg, H.T @ b)

# Поиск подходящего параметра λ
lambda_reg = lambda_min
for i in range(max_iterations):
    x_reg = solve_with_tikhonov(H, b, lambda_reg)
    relative_error = compute_relative_error(H, x_reg, b)

    # Если погрешность меньше или равна 5%, останавливаем поиск
    if relative_error <= target_error:
        break

    # Увеличиваем параметр λ, чтобы добиться стабилизации
    lambda_reg *= 1.5

    # Прерываем поиск, если превышено максимальное значение λ
    if lambda_reg > lambda_max:
        print(f"Не удалось достичь требуемой погрешности в пределах {lambda_max} после {i+1} итераций.")
        break

# Вывод решения и погрешности
if relative_error <= target_error:
    print(f"Найдено решение с λ = {lambda_reg:.2e} за {i+1} итераций.")
    print(f"Решение x: {x_reg}")
    print(f"Относительная погрешность: {relative_error * 100:.2f}%")
else:
    print(f"Не удалось найти решение с погрешностью ≤ 5%. Текущая погрешность: {relative_error * 100:.2f}%")

Что делает код:

1. Генерация матрицы Гильберта и вектора: Создается плохо обусловленная матрица $H$ и случайный вектор $b$.
2. Функции:
   • compute_relative_error вычисляет относительную погрешность.
   • solve_with_tikhonov решает систему с регуляризацией Тихонова для заданного значения $\lambda$.
3. Цикл подбора:
   • Цикл ищет значение $\lambda$, увеличивая его в 1.5 раза на каждой итерации, до тех пор, пока относительная погрешность не станет меньше или равна 5%.
   • Лимит итераций и максимальное значение $\lambda$ предотвращают слишком долгий поиск.

Результат:

Если найдется подходящее $\lambda$, код выведет решение и относительную погрешность.