Com base no entendimento de operações matriciais e decomposição em valores singulares (SVD), você está pronto para aplicar esses conceitos em um cenário prático: compressão de imagens. A SVD é uma ferramenta poderosa para reduzir a dimensionalidade dos dados e é amplamente utilizada no processamento de imagens para comprimir imagens mantendo o máximo possível das informações originais. Neste desafio, será utilizado `scipy.linalg.svd` para comprimir uma matriz de imagem em tons de cinza truncando seus valores singulares e, em seguida, reconstruir a imagem a partir dos dados reduzidos. Essa abordagem demonstra como a SVD pode equilibrar qualidade da imagem e eficiência de armazenamento.


import unittest
import user_code
import ast
import re   
import unittest
import numpy as np
from scipy.linalg import svd
import importlib

class TestTask(unittest.TestCase):
    def test_return_shape(self):
        import user_code
        importlib.reload(user_code)
        image = np.random.rand(8, 6)
        k = 3
        compressed = user_code.compress_image_svd(image, k)
        _dynamic_test(
            self,
            isinstance(compressed, np.ndarray) and compressed.shape == image.shape,
            "Returned matrix has the same shape as input image.",
            f"Expected shape {image.shape}, got {getattr(compressed, 'shape', None)}."
        )

    def test_top_k_reconstruction(self):
        import user_code
        importlib.reload(user_code)
        np.random.seed(0)
        image = np.random.rand(5, 5)
        k = 2
        U, S, VT = svd(image, full_matrices=False)
        U_k = U[:, :k]
        S_k = np.diag(S[:k])
        VT_k = VT[:k, :]
        expected = U_k @ S_k @ VT_k
        actual = user_code.compress_image_svd(image, k)
        _dynamic_test(
            self,
            np.allclose(actual, expected),
            "Matrix reconstructed correctly using top k singular values.",
            "Reconstructed matrix does not match expected result using top k singular values."
        )

    def test_full_rank_reconstruction(self):
        import user_code
        importlib.reload(user_code)
        np.random.seed(1)
        image = np.random.rand(7, 7)
        U, S, VT = svd(image, full_matrices=False)
        full_rank = np.linalg.matrix_rank(image)
        compressed = user_code.compress_image_svd(image, full_rank)
        _dynamic_test(
            self,
            np.allclose(compressed, image),
            "Full-rank SVD reconstruction matches original image.",
            "Full-rank SVD reconstruction does not match original image."
        )

    def test_low_rank_approximation(self):
        import user_code
        importlib.reload(user_code)
        np.random.seed(2)
        image = np.random.rand(10, 10)
        k = 1
        compressed = user_code.compress_image_svd(image, k)
        # Should be a low-rank approximation, not equal to original
        _dynamic_test(
            self,
            not np.allclose(compressed, image),
            "Low-rank approximation does not exactly match original image (as expected).",
            "Low-rank approximation should not exactly match original image."
        )
        # Should be closer to original than a zero matrix
        zero_approx = np.zeros_like(image)
        orig_norm = np.linalg.norm(image - compressed)
        zero_norm = np.linalg.norm(image - zero_approx)
        _dynamic_test(
            self,
            orig_norm < zero_norm,
            "Low-rank approximation is closer to the original than a zero matrix.",
            "Low-rank approximation is not closer to the original than a zero matrix."
        )

    def test_handles_rectangular(self):
        import user_code
        importlib.reload(user_code)
        np.random.seed(3)
        image = np.random.rand(12, 8)
        k = 4
        compressed = user_code.compress_image_svd(image, k)
        _dynamic_test(
            self,
            isinstance(compressed, np.ndarray) and compressed.shape == image.shape,
            "Handles rectangular matrices and returns correct shape.",
            f"Expected shape {image.shape}, got {getattr(compressed, 'shape', None)}."
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

Um curso abrangente projetado para estudantes com forte base em matemática e habilidades intermediárias a avançadas em Python, com foco no uso do SciPy para computação científica, otimização, integração e operações matemáticas avançadas.

Explore a estrutura, os módulos principais e os recursos essenciais do SciPy para computação científica.

Mergulhe nas poderosas capacidades de álgebra linear do SciPy para resolver problemas matemáticos do mundo real.

Domine técnicas de otimização e algoritmos de busca de raízes usando SciPy para problemas científicos e de engenharia.

Explore operações matemáticas avançadas, incluindo integração, interpolação e processamento de sinais básico com o SciPy.

Desafio: SVD para Compressão de Imagens

Solução