Per valutare il perceptrone creato in precedenza, verrà utilizzato un dataset contenente **due caratteristiche di input** e **due classi distinte** (`0` e `1`):

Questo dataset è **bilanciato**, con 500 campioni della classe `1` e 500 campioni della classe `0`. Pertanto, **accuracy** è una metrica sufficiente per la valutazione in questo caso, che può essere calcolata utilizzando la funzione `accuracy_score()`:

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

`y_true` rappresenta le etichette reali, mentre `y_pred` rappresenta le etichette predette.

Il dataset è memorizzato in `perceptron.py` come due **array NumPy**: `X` (caratteristiche di input) e `y` (etichette corrispondenti), quindi verranno semplicemente importati. Questo file contiene anche `model`, che è l'istanza della classe `Perceptron` creata in precedenza.

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

Le reti neurali sono potenti algoritmi ispirati alla struttura del cervello umano, utilizzati per risolvere complessi problemi di machine learning. Costruirai una rete neurale da zero per comprenderne il funzionamento. Al termine di questo corso, sarai in grado di creare reti neurali per risolvere problemi di classificazione e regressione utilizzando la libreria scikit-learn.

Per prima cosa, discuteremo cosa sia una rete neurale e come funziona. Considereremo inoltre l'ambito delle sue applicazioni.

Successivamente, proveremo a costruire una nostra rete neurale e valuteremo quanto sia efficiente nell'apprendimento. Prenderemo inoltre in considerazione una soluzione già pronta dalla libreria scikit-learn.

Infine, forniremo alcune informazioni aggiuntive utili su come comprendere quale modello utilizzare e quali tipi di reti neurali esistono. Per completare il corso, verrà verificata la conoscenza acquisita.

Sfida: Valutazione del Percettrone

Soluzione