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

Learn the fundamental and advanced concepts needed to work with PyTorch efficiently. Gain a solid understanding tensors, including creation, operations, and reshaping. Explore the essentials of gradients, backpropagation, and linear regression before moving on to handling datasets. Master the skill needed build, train, and evaluate neural networks.

Explore the fundamentals of PyTorch, focusing on tensors—the core data structure used for computations. You will learn about tensor creation, random initialization, mathematical operations, and shape manipulation.

Explore key concepts for training models in PyTorch, including computing gradients and performing multi-step backpropagation. Master linear regression as a foundational machine learning model and introduces handling datasets efficiently.

Discover how to build, train, and evaluate neural networks using PyTorch. You will learn how to define a simple feedforward neural network, optimize its parameters through training, and assess its performance.

Challenge: Initializing Tensors

解答