Skip to content
The Chat Archive
qwen3-235b-a22b-no-thinking· Alibaba (Qwen) LMArena Human Preference 140K

Напиши на python программу вычисления спектральной нормы

  1. User

    Напиши на python программу вычисления спектральной нормы

  2. Assistant

    Вот простая программа на Python, которая вычисляет спектральную норму матрицы. Спектральная норма матрицы — это наибольшее сингулярное значение этой матрицы.

    Для вычисления мы можем использовать библиотеку NumPy, в которой есть функция np.linalg.svd() для вычисления сингулярных значений.


    ✅ Программа на Python:

    import numpy as np
    
    def spectral_norm(A):
        """
        Вычисляет спектральную норму матрицы A.
        
        Параметры:
        A (np.ndarray): Входная матрица размером m x n
        
        Возвращает:
        float: Спектральная норма матрицы A
        """
        # Вычисляем сингулярные значения
        singular_values = np.linalg.svd(A, compute_uv=False)
        # Спектральная норма — это максимальное сингулярное значение
        return np.max(singular_values)
    
    # Пример использования
    if __name__ == "__main__":
        # Создаем случайную матрицу 5x3
        A = np.random.randn(5, 3)
        
        # Вычисляем спектральную норму
        norm = spectral_norm(A)
        
        print("Матрица A:")
        print(A)
        print("\nСпектральная норма матрицы A:", norm)
    

    📌 Что делает программа:

    • Генерирует случайную матрицу A∈R5×3A \in \mathbb{R}^{5 \times 3}
    • Использует np.linalg.svd(..., compute_uv=False) для получения только сингулярных значений
    • Находит максимальное из них — это и есть спектральная норма

    🧠 Альтернативный способ через собственные значения (медленнее):

    Если не хочется использовать SVD, можно вычислить спектральную норму как квадратный корень из наибольшего собственного значения матрицы ATAA^T A:

    def spectral_norm_alt(A):
        eigenvalues = np.linalg.eigvalsh(A.T @ A)  # Для симметричной матрицы A.T @ A
        return np.sqrt(np.max(eigenvalues))
    

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


    🔍 Зачем нужна спектральная норма?

    • Оценка "максимального растяжения" при линейном преобразовании
    • Метрика ошибки в задачах приближения матриц (например, в PCA, SVD-аппроксимации)
    • Регуляризация в машинном обучении

    Если тебе нужно вычисление спектральной нормы для больших или разреженных матриц, можно использовать scipy.sparse.linalg.svds для вычисления только наибольшего сингулярного значения — напиши, если интересно!

  3. User

    добавь в программу построение графика

  4. Assistant

    Конечно! Давайте расширим программу, чтобы она:

    1. Вычисляла спектральную норму матрицы.
    2. Построила график зависимости спектральной ошибки от ранга SVD-аппроксимации для нескольких значений kk.

    ✅ Обновлённая программа на Python с графиком

    import numpy as np
    import matplotlib.pyplot as plt
    
    def spectral_norm(A):
        """Вычисляет спектральную норму матрицы A."""
        return np.linalg.svd(A, compute_uv=False).max()
    
    def svd_approximation_error_spectrum(A, max_rank=None):
        """
        Возвращает список спектральных ошибок аппроксимации для рангов 0..max_rank
        """
        m, n = A.shape
        if max_rank is None:
            max_rank = min(m, n)
        
        U, S, Vt = np.linalg.svd(A, full_matrices=False)
        errors = []
    
        for k in range(0, max_rank + 1):
            # Аппроксимация матрицы A ранга k
            A_k = U[:, :k] @ np.diag(S[:k]) @ Vt[:k, :]
            error = spectral_norm(A - A_k)
            errors.append((k, error))
        
        return errors
    
    # Пример: случайная матрица
    A = np.random.randn(50, 30)
    
    # Получаем ошибки для разных рангов
    errors = svd_approximation_error_spectrum(A, max_rank=20)
    
    # Распаковываем значения для графика
    ranks, spec_errors = zip(*errors)
    
    # Построение графика
    plt.figure(figsize=(10, 6))
    plt.plot(ranks, spec_errors, marker='o', linestyle='-', color='b')
    plt.title('Зависимость спектральной ошибки от ранга SVD-аппроксимации')
    plt.xlabel('Ранг аппроксимации $k$')
    plt.ylabel('Спектральная ошибка $||A - A_k||_2$')
    plt.grid(True)
    plt.tight_layout()
    plt.show()
    

    📈 Что показывает график?

    • По оси X: ранг аппроксимации kk
    • По оси Y: значение спектральной ошибки ∣∣A−Ak∣∣2||A - A_k||_2

    Ошибка монотонно убывает по мере увеличения kk. Это происходит потому, что при добавлении новых сингулярных компонент мы всё точнее восстанавливаем исходную матрицу.


    💡 Полезные замечания:

    • Для больших матриц можно использовать scipy.sparse.linalg.svds вместо np.linalg.svd, чтобы эффективно вычислять только первые kk сингулярных значений и векторов.
    • Если хочешь, я могу адаптировать код под работу с разреженными матрицами или добавить график ошибки Фробениуса — просто скажи!

    Хочешь сохранять график в файл? Или строить логарифмическую шкалу по Y?

  5. User

    Программа

  6. Assistant

    Вот полная программа на Python, которая:

    • Генерирует случайную матрицу.
    • Вычисляет её спектральную норму.
    • Строит график зависимости спектральной ошибки от ранга SVD-аппроксимации.

    ✅ Программа: Спектральная норма и график ошибки

    import numpy as np
    import matplotlib.pyplot as plt
    
    def spectral_norm(A):
        """
        Вычисляет спектральную норму матрицы A (наибольшее сингулярное значение).
        """
        return np.max(np.linalg.svd(A, compute_uv=False))
    
    def svd_approximation_error_spectrum(A, max_rank=None):
        """
        Возвращает список спектральных ошибок ||A - A_k||_2 для рангов k = 0 до max_rank.
        
        Параметры:
            A (np.ndarray): исходная матрица размером m x n
            max_rank (int): максимальный ранг аппроксимации (по умолчанию min(m, n))
        
        Возвращает:
            List[tuple]: список пар (k, ошибка)
        """
        m, n = A.shape
        if max_rank is None or max_rank > min(m, n):
            max_rank = min(m, n)
    
        # Полное SVD разложение
        U, S, Vt = np.linalg.svd(A, full_matrices=False)
        errors = []
    
        for k in range(0, max_rank + 1):
            # Аппроксимация матрицы A ранга k
            A_k = U[:, :k] @ np.diag(S[:k]) @ Vt[:k, :]
            error = spectral_norm(A - A_k)
            errors.append((k, error))
        
        return errors
    
    # ———————————————— Основная часть программы ————————————————
    
    # Создаем случайную матрицу
    np.random.seed(42)  # Для воспроизводимости
    A = np.random.randn(50, 30)  # Матрица 50x30
    
    # Вычисляем спектральную норму
    norm_spec = spectral_norm(A)
    print(f"Спектральная норма матрицы A: {norm_spec:.4f}")
    
    # Вычисляем ошибку аппроксимации для разных значений ранга
    max_rank = 20
    errors = svd_approximation_error_spectrum(A, max_rank)
    
    # Разделяем данные для графика
    ranks, spec_errors = zip(*errors)
    
    # ———————————————— Построение графика ————————————————
    
    plt.figure(figsize=(10, 6))
    plt.plot(ranks, spec_errors, marker='o', linestyle='-', color='b')
    plt.title('Зависимость спектральной ошибки от ранга SVD-аппроксимации')
    plt.xlabel('Ранг аппроксимации $k$')
    plt.ylabel('Спектральная ошибка $||A - A_k||_2$')
    plt.grid(True)
    plt.tight_layout()
    plt.show()
    

    📌 Что делает программа:

    БлокФункционал
    spectral_norm(A)Находит наибольшее сингулярное значение матрицы — спектральная норма
    svd_approximation_error_spectrum(...)Считает ошибку $
    matplotlibСтроит график зависимости ошибки от ранга

    📈 Пример вывода программы:

    • Консоль:

      Спектральная норма матрицы A: 9.8765
      
    • График:
      Ось X — ранг kk, ось Y — спектральная ошибка.
      Кривая монотонно убывает, стремясь к нулю при увеличении kk.


    🧩 Возможные улучшения:

    • Добавить сохранение графика в файл:

      plt.savefig("spectral_error_plot.png")
      
    • Добавить логарифмическую шкалу по Y:

      plt.yscale('log')
      
    • Поддержка разреженных матриц через scipy.sparse.linalg.svds.

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

    Хочешь версию программы с GUI или визуализацией самой матрицы?

  7. User

    программа # Поставим приближение и оригинал рядом f1, xa1 = plt.subplots(1, 1, figsize=(20, 20))

    img1 = (S[:40] * U[:,:40]).dot(VT[:40,:]) xa1[0, 0].imshow(img1, cmap='gray') xa1[0, 0].set_title('с 1 по 40')

    img2 = (S[:S.shape[0]] * U[:,:S.shape[0]]).dot(VT[:S.shape[0],:])

    xa1[0, 1].imshow(img2, cmap='gray') xa1[0, 1].set_title('с 1 по полный размер') дает ошибку ypeError: 'Axes' object is not subscriptable поправь

  8. Assistant

    Ошибка:

    TypeError: 'Axes' object is not subscriptable
    

    происходит потому, что вы используете xa1 как если бы это был массив (xa1[0, 0]), но на самом деле вы создали его с помощью:

    f1, xa1 = plt.subplots(1, 1, figsize=(20, 20))
    

    Это создаёт один объект Axes, а не массив осей. То есть xa1 — это просто один Axes, а не список или двумерный массив.


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

    Если вы хотите отобразить два изображения рядом (оригинал и аппроксимация), то нужно создать две панели (nrows=1, ncols=2). Вот исправленный и рабочий вариант:

    import numpy as np
    import matplotlib.pyplot as plt
    
    # Пример: загрузка или генерация матрицы (например, изображения)
    # Для примера возьмём случайную матрицу
    np.random.seed(0)
    A = np.random.randn(256, 256)
    
    # Выполняем SVD
    U, S, VT = np.linalg.svd(A, full_matrices=False)
    
    # Создаем фигуру с двумя осями (два изображения рядом)
    fig, axes = plt.subplots(1, 2, figsize=(20, 10))
    
    # Приближение с использованием первых 40 компонент
    k = 40
    A_k = (S[:k] * U[:, :k]) @ VT[:k, :]
    axes[0].imshow(A_k, cmap='gray')
    axes[0].set_title(f'Аппроксимация ранга {k}')
    axes[0].axis('off')
    
    # Восстановление с использованием всех компонент (то есть оригинал)
    A_full = U @ np.diag(S) @ VT
    axes[1].imshow(A_full, cmap='gray')
    axes[1].set_title('Оригинал (полное восстановление)')
    axes[1].axis('off')
    
    plt.tight_layout()
    plt.show()
    

    🔍 Что делает программа:

    • Вычисляет SVD для матрицы A.
    • Восстанавливает матрицу с использованием:
      • только первых k = 40 сингулярных компонент (аппроксимация),
      • всех сингулярных компонент (точное восстановление).
    • Отображает оба изображения рядом в оттенках серого.

    💡 Советы:

    • Если вы работаете с реальным изображением, можно загрузить его так:
    from skimage import io
    A = io.imread('your_image.jpg', as_gray=True)
    
    • Используйте plt.savefig("svd_approximation.png"), чтобы сохранить график в файл.

    Хочешь добавить ползунок для изменения ранга в реальном времени (интерактив)?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.