Para evaluar el perceptrón previamente creado, se utilizará un conjunto de datos que contiene **dos características de entrada** y **dos clases distintas** (`0` y `1`):

Este conjunto de datos está **balanceado**, con 500 muestras de la clase `1` y 500 muestras de la clase `0`. Por lo tanto, la **precisión** es una métrica suficiente para la evaluación en este caso, la cual se puede calcular utilizando la función `accuracy_score()`:

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

`y_true` representa las etiquetas reales, mientras que `y_pred` representa las etiquetas predichas.

El conjunto de datos se almacena en `perceptron.py` como dos **arreglos de NumPy**: `X` (características de entrada) y `y` (etiquetas correspondientes), por lo que simplemente se importarán. Este archivo también contiene `model`, que es la instancia de la clase `Perceptron` que se creó previamente.

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

Las redes neuronales son algoritmos potentes inspirados en la estructura del cerebro humano que se utilizan para resolver problemas complejos de aprendizaje automático. Construirá su propia red neuronal desde cero para comprender su funcionamiento. Tras este curso, podrá crear redes neuronales para resolver problemas de clasificación y regresión utilizando la biblioteca scikit-learn.

Primero, discutiremos qué es una red neuronal y cómo funciona. También se considerará el alcance de su aplicación.

A continuación, intentaremos construir nuestra propia red neuronal y evaluaremos su eficiencia en el aprendizaje. También analizaremos una solución ya implementada de la biblioteca scikit-learn.

Finalmente, le proporcionaremos información adicional útil sobre cómo determinar qué modelo utilizar y qué tipos de redes neuronales existen. Para completar el curso, se evaluarán los conocimientos adquiridos.

Desafío: Evaluación del Perceptrón

Solución