To evaluate the previously created perceptron, you will use a dataset containing **two input features** and **two distinct classes** (`0` and `1`):

This dataset is **balanced**, with 500 samples from class `1` and 500 samples from class `0`. Therefore, **accuracy** is a sufficient metric for evaluation in this case, which can be calculated using the `accuracy_score()` function:

```python
accuracy_score(y_true, y_pred)
```

`y_true` represents the actual labels, while `y_pred` represents the predicted labels.

The dataset is stored in `perceptron.py` as two **NumPy arrays**: `X` (input features) and `y` (corresponding labels), so they will be simply imported. This file also contains `model`, which is the instance of the `Perceptron` class you previously created. 

import unittest
import importlib
import numpy as np


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


class TestPerceptronEvaluation(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.user_code = importlib.import_module("user_code")

        from sklearn.model_selection import train_test_split
        from sklearn.metrics import accuracy_score
        from perceptron import X, y, model

        cls.train_test_split = train_test_split
        cls.accuracy_score = accuracy_score
        cls.X = X
        cls.y = y
        cls.model = model

        cls.X_train, cls.X_test, cls.y_train, cls.y_test = cls.train_test_split(
            cls.X, cls.y, test_size=0.2, random_state=10
        )

    def test_split_ratio_and_shapes(self):
        user_vars = [v for v in dir(self.user_code) if v.startswith("X_") or v.startswith("y_")]
        has_train = any("train" in v for v in user_vars)
        has_test = any("test" in v for v in user_vars)
        _dynamic_test(
            self,
            has_train and has_test,
            "Dataset correctly split into train and test sets",
            "Train-test split variables not found (X_train/X_test/y_train/y_test)",
        )

        if hasattr(self.user_code, "X_train") and hasattr(self.user_code, "X_test"):
            n_train = len(self.user_code.X_train)
            n_test = len(self.user_code.X_test)
            total = n_train + n_test
            ratio = round(n_test / total, 1)
            _dynamic_test(
                self,
                abs(ratio - 0.2) < 0.05,
                "Test set ratio is approximately 20%",
                f"Test set ratio incorrect: {ratio*100:.1f}%",
            )

    def test_model_trained(self):
        # Save initial weights (copy)
        initial_weights = [layer.weights.copy() for layer in self.model.layers]

        # Fit model on a few iterations
        self.user_code.model.fit(self.X_train, self.y_train, epochs=1, learning_rate=0.05)

        # Compare with previous weights
        updated_weights = [layer.weights for layer in self.model.layers]
        changed = any(not np.allclose(w0, w1, atol=1e-12) for w0, w1 in zip(initial_weights, updated_weights))

        _dynamic_test(
            self,
            changed,
            "Model weights updated successfully during training",
            "Model weights did not update after training",
        )

    def test_predictions_type_and_shape(self):
        preds = getattr(self.user_code, "predictions", None)
        _dynamic_test(
            self,
            preds is not None and isinstance(preds, np.ndarray),
            "Predictions stored in a NumPy array",
            "Predictions variable missing or not a NumPy array",
        )

        if preds is not None:
            _dynamic_test(
                self,
                preds.ndim == 1 or preds.shape[1] == 1,
                "Predictions have correct shape",
                f"Predictions shape incorrect: {preds.shape}",
            )

    def test_accuracy_computation(self):
        from sklearn.metrics import accuracy_score
        preds_ref = np.array([self.user_code.model.forward(x)[0] for x in self.X_test])
        acc_ref = accuracy_score(self.y_test, np.round(preds_ref))
        _dynamic_test(
            self,
            0.5 <= acc_ref <= 1.0,
            "Accuracy computed successfully",
            f"Accuracy value unreasonable: {acc_ref}",
        )


if __name__ == "__main__":
    unittest.main(argv=["first-arg-is-ignored"], exit=False)


test_code.py

Focuses on the mathematical foundations and core mechanics of neural networks. Learn how to implement perceptrons, activation functions, forward and backward propagation, loss calculation, and gradient descent from scratch using Python and NumPy, without relying on high-level frameworks. Gain practical, hands-on experience and deep intuition for how neural networks work at the lowest level.

Challenge: Evaluating the Perceptron

解答