import unittest
import importlib
import torch
import numpy as np


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):

    # --- tensor_1: zeros 2x3 ---
    def test_tensor1_exists(self):
        import user_code
        cond = hasattr(user_code, "tensor_1")
        _dynamic(
            self,
            cond,
            "`tensor_1` is successfully defined.",
            "`tensor_1` is missing. Make sure to assign your 2x3 zero tensor to `tensor_1`."
        )

    def test_tensor1_is_tensor(self):
        import user_code
        cond = isinstance(user_code.tensor_1, torch.Tensor)
        _dynamic(
            self,
            cond,
            "`tensor_1` is correctly created as a PyTorch tensor.",
            "`tensor_1` must be a PyTorch tensor created with `torch.zeros()`."
        )

    def test_tensor1_shape_and_values(self):
        import user_code
        t = user_code.tensor_1
        cond = t.shape == (2, 3) and torch.all(t == 0)
        _dynamic(
            self,
            cond,
            "`tensor_1` has the correct shape (2x3) and is filled with zeros.",
            "`tensor_1` is incorrect. It must be a 2x3 tensor of zeros created using `torch.zeros(2, 3)`."
        )

    # --- tensor_2: arange 1..10 ---
    def test_tensor2_exists(self):
        import user_code
        cond = hasattr(user_code, "tensor_2")
        _dynamic(
            self,
            cond,
            "`tensor_2` is successfully defined.",
            "`tensor_2` is missing. Assign the tensor created with `torch.arange(1, 11)` to `tensor_2`."
        )

    def test_tensor2_values(self):
        import user_code
        t = user_code.tensor_2
        try:
            expected = torch.arange(1, 11)
            cond = isinstance(t, torch.Tensor) and torch.equal(t, expected)
        except:
            cond = False

        _dynamic(
            self,
            cond,
            "`tensor_2` correctly contains values from 1 to 10.",
            "`tensor_2` must be created using `torch.arange(1, 11)` to generate values from 1 to 10 inclusive."
        )

    # --- tensor_3: linspace 2..4, steps=10 ---
    def test_tensor3_exists(self):
        import user_code
        cond = hasattr(user_code, "tensor_3")
        _dynamic(
            self,
            cond,
            "`tensor_3` is successfully defined.",
            "`tensor_3` is missing. Assign the tensor created with `torch.linspace(2, 4, steps=10)` to `tensor_3`."
        )

    def test_tensor3_values(self):
        import user_code
        t = user_code.tensor_3
        try:
            expected = torch.linspace(2, 4, steps=10)
            cond = isinstance(t, torch.Tensor) and torch.allclose(t, expected)
        except:
            cond = False

        _dynamic(
            self,
            cond,
            "`tensor_3` correctly contains 10 evenly spaced values between 2 and 4.",
            "`tensor_3` must be created using `torch.linspace(2, 4, steps=10)` to generate the required values."
        )

    # --- Ensure something was printed ---
    def test_output_printed(self):
        import user_code

        import io, sys
        buf = io.StringIO()
        sys.stdout = buf

        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        cond = len(buf.getvalue().strip()) > 0

        _dynamic(
            self,
            cond,
            "All tensors are printed successfully.",
            "No output detected. Ensure that you print all three tensors as required."
        )


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: Inicialización de Tensores

Solución