Building on your understanding of matrix operations and singular value decomposition (SVD), you are ready to apply these concepts to a practical scenario: image compression. SVD is a powerful tool for reducing the dimensionality of data, and it is widely used in image processing to compress images while retaining as much of the original information as possible. In this challenge, you will use `scipy.linalg.svd` to compress a grayscale image matrix by truncating its singular values, then reconstruct the image from the reduced data. This approach demonstrates how SVD can balance image quality and storage efficiency.


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

A comprehensive course designed for students with strong math backgrounds and intermediate to advanced Python skills, focusing on leveraging SciPy for scientific computing, optimization, integration, and advanced mathematical operations.

Explore the structure, core modules, and essential features of SciPy for scientific computing.

Dive into SciPy's powerful linear algebra capabilities for solving real-world mathematical problems.

Master optimization techniques and root-finding algorithms using SciPy for scientific and engineering problems.

Explore advanced mathematical operations including integration, interpolation, and basic signal processing with SciPy.

Challenge: SVD for Image Compression

Oplossing

Awesome!

Challenge: SVD for Image Compression

Oplossing