import unittest
import importlib
import torch


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

    # -------- manual seed --------
    def test_seed_set(self):
        with open("user_code.py") as f:
            src = f.read()

        cond = "torch.manual_seed" in src

        _dynamic(
            self,
            cond,
            "The manual seed is set correctly.",
            "You must set a manual seed using `torch.manual_seed()` before creating any tensors."
        )

    # -------- weights_layer1 --------
    def test_weights1_exists(self):
        import user_code
        cond = hasattr(user_code, "weights_layer1")
        _dynamic(
            self,
            cond,
            "`weights_layer1` is successfully defined.",
            "`weights_layer1` is missing. Assign your 3x4 uniform-random tensor to this variable."
        )

    def test_weights1_valid(self):
        import user_code
        try:
            t = user_code.weights_layer1
            cond = (
                isinstance(t, torch.Tensor)
                and t.shape == (3, 4)
                and torch.all(t >= 0)
                and torch.all(t < 1)
            )
        except:
            cond = False

        _dynamic(
            self,
            cond,
            "`weights_layer1` is a valid 3x4 tensor with values uniformly sampled from [0, 1).",
            "`weights_layer1` must be created with `torch.rand(3, 4)` so that all values lie between 0 and 1."
        )

    # -------- biases_layer1 --------
    def test_biases1_exists(self):
        import user_code
        cond = hasattr(user_code, "biases_layer1")
        _dynamic(
            self,
            cond,
            "`biases_layer1` is successfully defined.",
            "`biases_layer1` is missing. You must assign a 1x4 zero tensor to this variable."
        )

    def test_biases1_valid(self):
        import user_code
        try:
            t = user_code.biases_layer1
            cond = (
                isinstance(t, torch.Tensor)
                and t.shape == (1, 4)
                and torch.all(t == 0)
            )
        except:
            cond = False

        _dynamic(
            self,
            cond,
            "`biases_layer1` is correctly created as a 1x4 tensor of zeros.",
            "`biases_layer1` must be a 1x4 zero tensor created using `torch.zeros(1, 4)`."
        )

    # -------- weights_layer2 --------
    def test_weights2_exists(self):
        import user_code
        cond = hasattr(user_code, "weights_layer2")
        _dynamic(
            self,
            cond,
            "`weights_layer2` is successfully defined.",
            "`weights_layer2` is missing. Assign a 4x2 integer tensor created with `torch.randint()`."
        )

    def test_weights2_valid(self):
        import user_code
        try:
            t = user_code.weights_layer2
            cond = (
                isinstance(t, torch.Tensor)
                and t.shape == (4, 2)
                and torch.all(t >= -5)
                and torch.all(t <= 5)
                and torch.equal(t, t.int())
            )
        except:
            cond = False

        _dynamic(
            self,
            cond,
            "`weights_layer2` is a valid 4x2 integer tensor with values in the range [-5, 5].",
            "`weights_layer2` must be created using `torch.randint(-5, 5, (4, 2))` to generate integer weights in the specified range."
        )

    # -------- printing output --------
    def test_printed_output(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 as required.",
            "No output detected. Ensure that you print all three tensors exactly as instructed."
        )


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


test_code.py

Lær de grunnleggende og avanserte konseptene som trengs for å arbeide effektivt med PyTorch. Få en solid forståelse av tensorer, inkludert opprettelse, operasjoner og omforming. Utforsk det essensielle innen gradienter, tilbakepropagering og lineær regresjon før du går videre til håndtering av datasett. Mestre ferdighetene som trengs for å bygge, trene og evaluere nevrale nettverk.

Utforsk grunnleggende konsepter i PyTorch, med fokus på tensorer—den sentrale datastrukturen som brukes til beregninger. Du vil lære om opprettelse av tensorer, tilfeldig initialisering, matematiske operasjoner og manipulering av former.

Utforsk sentrale konsepter for trening av modeller i PyTorch, inkludert beregning av gradienter og utførelse av flerstegs tilbakepropagering. Behersk lineær regresjon som en grunnleggende maskinlæringsmodell og introduksjon til effektiv håndtering av datasett.

Utforsk hvordan du bygger, trener og evaluerer nevrale nettverk ved hjelp av PyTorch. Du vil lære å definere et enkelt feedforward nevralt nettverk, optimalisere dets parametere gjennom trening og vurdere ytelsen.

Utfordring: Initialisering av Modellens Vekter og Bias

Løsning

Awesome!

Utfordring: Initialisering av Modellens Vekter og Bias

Løsning