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

Transição de bibliotecas de alto nível para a flexibilidade do PyTorch. Domínio dos blocos fundamentais do deep learning ao trabalhar com tensores, a principal estrutura de dados do PyTorch. Exploração da diferenciação automática com gradientes, implementação do backpropagation e construção de redes neurais completas do zero. Aprendizado sobre como lidar com conjuntos de dados do mundo real e gerenciar todo o ciclo de treinamento – desde a inicialização dos pesos até a avaliação do modelo.

Desafio: Inicializando Tensores

Solução