import unittest
import torch
import importlib
import sys
import io


def _dynamic(test, cond, ok, fail):
    if cond:
        test._testMethodName = ok
        test.assertTrue(True)
    else:
        test._testMethodName = fail
        test.fail(fail)


class TestUserCode(unittest.TestCase):

    def setUp(self):
        # Reference tensor with known shape 3x4
        self.original_shape = (3, 4)

    # -------- Existence tests --------
    def test_reshaped_exists(self):
        import user_code
        cond = hasattr(user_code, "reshaped_tensor")
        _dynamic(
            self,
            cond,
            "`reshaped_tensor` variable is defined.",
            "`reshaped_tensor` is missing. Reshape the tensor using `tensor.reshape(2, 6)`."
        )

    def test_view_exists(self):
        import user_code
        cond = hasattr(user_code, "view_tensor")
        _dynamic(
            self,
            cond,
            "`view_tensor` variable is defined.",
            "`view_tensor` is missing. Create it using `.view(4, 3)`."
        )

    def test_unsqueezed_exists(self):
        import user_code
        cond = hasattr(user_code, "unsqueezed_tensor")
        _dynamic(
            self,
            cond,
            "`unsqueezed_tensor` variable is defined.",
            "`unsqueezed_tensor` is missing. Add a dimension using `.unsqueeze(2)`."
        )

    def test_squeezed_exists(self):
        import user_code
        cond = hasattr(user_code, "squeezed_tensor")
        _dynamic(
            self,
            cond,
            "`squeezed_tensor` variable is defined.",
            "`squeezed_tensor` is missing. Remove the added dimension using `.squeeze(2)`."
        )

    # -------- Correctness tests --------
    def test_reshaped_correct(self):
        import user_code
        t = user_code.tensor
        reshaped = user_code.reshaped_tensor

        cond = isinstance(reshaped, torch.Tensor) and reshaped.shape == (2, 6)
        _dynamic(
            self,
            cond,
            "`reshaped_tensor` has the correct shape (2x6).",
            "`reshaped_tensor` must have shape (2, 6). Use `tensor.reshape(2, 6)`."
        )

    def test_view_correct(self):
        import user_code
        view = user_code.view_tensor

        cond = isinstance(view, torch.Tensor) and view.shape == (4, 3)
        _dynamic(
            self,
            cond,
            "`view_tensor` has the correct shape (4x3).",
            "`view_tensor` must be created using `.view(4, 3)`."
        )

    def test_unsqueezed_correct(self):
        import user_code
        unsq = user_code.unsqueezed_tensor

        cond = isinstance(unsq, torch.Tensor) and unsq.shape == (2, 6, 1)
        _dynamic(
            self,
            cond,
            "`unsqueezed_tensor` correctly adds a new dimension at index 2.",
            "`unsqueezed_tensor` must use `.unsqueeze(2)` and have shape (2, 6, 1)."
        )

    def test_squeezed_correct(self):
        import user_code
        sq = user_code.squeezed_tensor

        cond = isinstance(sq, torch.Tensor) and sq.shape == (2, 6)
        _dynamic(
            self,
            cond,
            "`squeezed_tensor` correctly removes the added dimension.",
            "`squeezed_tensor` must use `.squeeze(2)` and return to shape (2, 6)."
        )

    # -------- Print test --------
    def test_prints_output(self):
        import user_code
        buf = io.StringIO()
        sys.stdout = buf

        importlib.reload(user_code)

        sys.stdout = sys.__stdout__
        cond = len(buf.getvalue().strip()) > 0

        _dynamic(
            self,
            cond,
            "Tensor shapes and values are printed successfully.",
            "No output detected. Make sure all required tensors are printed."
        )


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


test_code.py

Transición de bibliotecas de alto nivel a la flexibilidad de PyTorch. Dominio de los componentes fundamentales del aprendizaje profundo mediante el trabajo con tensores, la estructura de datos principal de PyTorch. Exploración de la diferenciación automática con gradientes, implementación de retropropagación y construcción de redes neuronales completas desde cero. Manejo de conjuntos de datos del mundo real y gestión del ciclo completo de entrenamiento, desde la inicialización de pesos hasta la evaluación del modelo.

Desafío: Remodelación de Tensores

Solución