En vous appuyant sur votre compréhension des opérations matricielles et de la décomposition en valeurs singulières (SVD), vous êtes prêt à appliquer ces concepts à un cas pratique : la compression d'image. La SVD est un outil puissant pour réduire la dimensionnalité des données, et elle est largement utilisée dans le traitement d'images pour compresser celles-ci tout en conservant un maximum d'informations d'origine. Dans ce défi, vous utiliserez `scipy.linalg.svd` pour compresser une matrice d'image en niveaux de gris en tronquant ses valeurs singulières, puis vous reconstruirez l'image à partir des données réduites. Cette méthode illustre comment la SVD permet de trouver un équilibre entre la qualité de l'image et l'efficacité du stockage.


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

Un cours complet conçu pour les étudiants ayant de solides bases en mathématiques et des compétences intermédiaires à avancées en Python, axé sur l'utilisation de SciPy pour le calcul scientifique, l'optimisation, l'intégration et les opérations mathématiques avancées.

Découvrez la structure, les modules principaux et les fonctionnalités essentielles de SciPy pour le calcul scientifique.

Plongez dans les puissantes capacités d'algèbre linéaire de SciPy pour résoudre des problèmes mathématiques concrets.

Maîtriser les techniques d'optimisation et les algorithmes de recherche de racines avec SciPy pour des problèmes scientifiques et d'ingénierie.

Explorez des opérations mathématiques avancées, y compris l'intégration, l'interpolation et le traitement du signal de base avec SciPy.

Défi : SVD pour la compression d'image

Solution