import unittest
import torch
import importlib

def _dynamic_test(test_case, condition, success, failure):
    if condition:
        test_case._testMethodName = success
        test_case.assertTrue(True)
    else:
        test_case._testMethodName = failure
        test_case.fail(failure)

class TestUserCode(unittest.TestCase):

    def test_dropout_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code.model, "dropout"),
            "The Dropout layer is declared.",
            "Expected a Dropout layer named `dropout`."
        )

    def test_batchnorm_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code.model, "bn"),
            "The BatchNorm layer is declared.",
            "Expected a BatchNorm layer named `bn`."
        )

    def test_dropout_used_in_forward(self):
        import re
        with open("user_code.py", "r") as f:
            code = f.read()

        pattern = r"out\s*=\s*self\.dropout"
        _dynamic_test(
            self,
            re.search(pattern, code) is not None,
            "The Dropout layer is used in the forward pass.",
            "Expected Dropout to be applied in forward()."
        )

    def test_batchnorm_used_in_forward(self):
        import re
        with open("user_code.py", "r") as f:
            code = f.read()

        pattern = r"out\s*=\s*self\.bn"
        _dynamic_test(
            self,
            re.search(pattern, code) is not None,
            "The BatchNorm layer is used in the forward pass.",
            "Expected BatchNorm to be applied in forward()."
        )

    def test_output_shape_is_correct(self):
        import user_code
        output = user_code.output
        _dynamic_test(
            self,
            output.shape == (4, 10),
            "The output has shape (4, 10).",
            f"Expected output shape (4, 10), but got {output.shape}."
        )

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

test_main.py

Master the mathematical and practical foundations of neural network optimization, explore advanced regularization techniques, and gain hands-on experience with PyTorch and TensorFlow for robust model training.

Explore the mathematical underpinnings of neural network optimization, including gradients, loss surfaces, and the challenges of vanishing and exploding gradients.

Compare and implement advanced optimization algorithms and learning rate scheduling in neural network training.

Master the theory and application of regularization methods to prevent overfitting in neural networks.

Challenge: Integrate Dropout and BatchNorm

Oplossing