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

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.

Challenge: Reshaping Tensors

Lösung