Arvioidaksesi aiemmin luotua perceptronia, käytät aineistoa, joka sisältää **kaksi syöteominaisuutta** ja **kaksi erillistä luokkaa** (`0` ja `1`):

Tämä aineisto on **tasapainotettu**, sisältäen 500 näytettä luokasta `1` ja 500 näytettä luokasta `0`. Tästä syystä **tarkkuus** on riittävä mittari arviointiin tässä tapauksessa, ja se voidaan laskea käyttämällä `accuracy_score()`-funktiota:

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

`y_true` edustaa todellisia luokkia, kun taas `y_pred` edustaa ennustettuja luokkia.

Aineisto on tallennettu tiedostoon `perceptron.py` kahtena **NumPy-taulukkona**: `X` (syöteominaisuudet) ja `y` (vastaavat luokat), joten ne tuodaan suoraan. Tämä tiedosto sisältää myös `model`-olion, joka on aiemmin luomasi `Perceptron`-luokan instanssi.

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

Keskittyy neuroverkkojen matemaattisiin perusteisiin ja ydintoimintoihin. Sisältää perceptronien, aktivointifunktioiden, eteen- ja taaksepäin etenemisen, häviön laskennan sekä gradienttilaskun toteutuksen alusta alkaen Pythonilla ja NumPyllä ilman korkean tason kirjastoja. Tarjoaa käytännönläheistä kokemusta ja syvällistä ymmärrystä neuroverkkojen toiminnasta matalimmalla tasolla.

Haaste: Perceptronin Arviointi

Ratkaisu