Para construir un **perceptrón multicapa (MLP)**, es útil definir una clase `Perceptron`. Esta almacena una lista de objetos `Layer` que conforman la red:

```python
class Perceptron:
    def __init__(self, layers):
        self.layers = layers
```

El MLP utilizará tres valores:

* `input_size`: número de características de entrada;
* `hidden_size`: número de neuronas en cada capa oculta;
* `output_size`: número de neuronas en la capa de salida.

Así, el modelo consta de:

1. Una **capa de entrada**;
2. **Dos capas ocultas** (igual cantidad de neuronas, ReLU);
3. Una **capa de salida** (sigmoide).

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 TestPerceptron(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.user_code = importlib.import_module("user_code")
        np.random.seed(10)

        cls.input_size = 2
        cls.hidden_size = 3
        cls.output_size = 1

        cls.perceptron = cls.user_code.perceptron
        cls.layers = cls.perceptron.layers

    def test_layers_structure(self):
        _dynamic_test(
            self,
            len(self.layers) == 3,
            "Three layers are defined",
            "Incorrect number of layers defined",
        )

    def test_weights_shapes(self):
        shapes = [layer.weights.shape for layer in self.layers]
        expected = [
            (self.hidden_size, self.input_size),
            (self.hidden_size, self.hidden_size),
            (self.output_size, self.hidden_size),
        ]
        _dynamic_test(
            self,
            shapes == expected,
            "Weights shapes are correct",
            f"Weights shapes are incorrect: got {shapes}, expected {expected}",
        )

    def test_biases_shapes(self):
        shapes = [layer.biases.shape for layer in self.layers]
        expected = [
            (self.hidden_size, 1),
            (self.hidden_size, 1),
            (self.output_size, 1),
        ]
        _dynamic_test(
            self,
            shapes == expected,
            "Bias shapes are correct",
            "Bias shapes are incorrect",
        )

    def test_weights_range(self):
        all_in_range = all(
            np.all((layer.weights >= -1) & (layer.weights < 1)) for layer in self.layers
        )
        _dynamic_test(
            self,
            all_in_range,
            "All weights are within [-1, 1)",
            "Weights are outside expected range",
        )

    def test_biases_range(self):
        all_in_range = all(
            np.all((layer.biases >= -1) & (layer.biases < 1)) for layer in self.layers
        )
        _dynamic_test(
            self,
            all_in_range,
            "All biases are within [-1, 1)",
            "Biases are outside expected range",
        )

    def test_third_neuron_weights_second_hidden_layer(self):
        w_user = np.round(self.layers[1].weights[2], 2)
        np.random.seed(10)
        _ = np.random.uniform(-1, 1, (self.hidden_size, self.input_size))
        _ = np.random.uniform(-1, 1, (self.hidden_size, 1))
        ref_w = np.random.uniform(-1, 1, (self.hidden_size, self.hidden_size))
        np.round(ref_w[2], 2)
        _dynamic_test(
            self,
            np.allclose(w_user, np.round(ref_w[2], 2), atol=1e-6),
            "Weights of 3rd neuron in 2nd hidden layer are correct",
            "Weights of 3rd neuron in 2nd hidden layer are incorrect",
        )

    def test_output_layer_weights(self):
        w_user = np.round(self.layers[2].weights[0], 2)
        np.random.seed(10)
        # Hidden layer 1: weights + biases
        np.random.uniform(-1, 1, (self.hidden_size, self.input_size))
        np.random.uniform(-1, 1, (self.hidden_size, 1))
        # Hidden layer 2: weights + biases
        np.random.uniform(-1, 1, (self.hidden_size, self.hidden_size))
        np.random.uniform(-1, 1, (self.hidden_size, 1))
        # Output layer weights
        ref_w = np.random.uniform(-1, 1, (self.output_size, self.hidden_size))
        _dynamic_test(
            self,
            np.allclose(w_user, np.round(ref_w[0], 2), atol=1e-6),
            "Weights of output neuron are correct",
            "Weights of output neuron are incorrect",
        )


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: Creación de un Perceptrón

1. Inicialización de los parámetros de la capa (`init`)

2. Implementación de la propagación hacia adelante (`forward`)

3. Definición de las capas del MLP

Solución

Desafío: Creación de un Perceptrón

1. Inicialización de los parámetros de la capa (`init`)

2. Implementación de la propagación hacia adelante (`forward`)

3. Definición de las capas del MLP

Solución

Desafío: Creación de un Perceptrón

1. Inicialización de los parámetros de la capa (__init__)

2. Implementación de la propagación hacia adelante (forward)

3. Definición de las capas del MLP

Solución

Desafío: Creación de un Perceptrón

1. Inicialización de los parámetros de la capa (__init__)

2. Implementación de la propagación hacia adelante (forward)

3. Definición de las capas del MLP

Solución

1. Inicialización de los parámetros de la capa (`init`)

2. Implementación de la propagación hacia adelante (`forward`)

1. Inicialización de los parámetros de la capa (`init`)

2. Implementación de la propagación hacia adelante (`forward`)