import unittest
import torch
import importlib

# Helper for dynamic pass/fail messages
def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_w_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, "w"),
            "The `w` parameter is declared.",
            "Expected the `w` parameter to be declared."
        )

    def test_custom_step_updates_w_correctly(self):
        import user_code

        # Recompute expected value using the same logic
        torch.manual_seed(42)
        w_expected = torch.randn(1, requires_grad=True)
        x = torch.tensor([1.0, 2.0, 3.0])
        y_true = torch.tensor([2.0, 4.0, 6.0])
        lr = 0.1

        y_pred = w_expected * x
        loss = torch.mean((y_pred - y_true) ** 2)

        loss.backward()
        with torch.no_grad():
            w_expected -= lr * w_expected.grad

        expected_value = w_expected.item()
        actual_value = user_code.w.item()

        _dynamic_test(
            self,
            abs(actual_value - expected_value) < 1e-4,
            f"The custom optimizer step updates `w` correctly to `{expected_value:.4f}`.",
            f"Expected `w` to be `{expected_value:.4f}`, but got `{actual_value:.4f}`."
        )

    def test_grad_is_cleared(self):
        import user_code

        try:
            grad_value = user_code.w.grad
            condition = grad_value is not None and torch.all(grad_value == 0)
            failure_message = (
                "Expected `w.grad` to be cleared with `zero_()` after the update."
            )
        except Exception:
            condition = False
            failure_message = "Could not access `w.grad`. Make sure gradients are cleared."

        _dynamic_test(
            self,
            condition,
            "Gradients are cleared after the optimizer step.",
            failure_message
        )

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: Implement Custom Optimizer Step

Solución