Para construir um **perceptron multicamadas (MLP)**, é útil definir uma classe `Perceptron`. Ela armazena uma lista de objetos `Layer` que compõem a rede:

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

O MLP utilizará três valores:

* `input_size`: número de características de entrada;
* `hidden_size`: número de neurônios em cada camada oculta;
* `output_size`: número de neurônios na camada de saída.

Assim, o modelo consiste em:

1. Uma **camada de entrada**;
2. **Duas camadas ocultas** (mesma quantidade de neurônios, ReLU);
3. Uma **camada de saída** (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

Redes neurais são algoritmos avançados inspirados na estrutura do cérebro humano, utilizados para resolver problemas complexos de aprendizado de máquina. Você irá construir sua própria Rede Neural do zero para compreender seu funcionamento. Após este curso, será possível criar redes neurais para resolver problemas de classificação e regressão utilizando a biblioteca scikit-learn.

Primeiro, discutiremos o que é uma rede neural e como ela funciona. Também será considerado o escopo de sua aplicação.

Em seguida, tentaremos construir nossa própria rede neural e observar como ela lida com o aprendizado de forma eficiente. Também analisaremos uma solução pronta da biblioteca scikit-learn.

Por fim, forneceremos informações adicionais úteis sobre como entender qual modelo utilizar e quais tipos de redes neurais existem. Para concluir o curso, você será avaliado sobre o conhecimento adquirido.

Desafio: Criando um Perceptron

1. Inicialização dos parâmetros da camada (`init`)

2. Implementação da propagação direta (`forward`)

3. Definição das camadas do MLP

Solução

Desafio: Criando um Perceptron

1. Inicialização dos parâmetros da camada (`init`)

2. Implementação da propagação direta (`forward`)

3. Definição das camadas do MLP

Solução

Desafio: Criando um Perceptron

1. Inicialização dos parâmetros da camada (__init__)

2. Implementação da propagação direta (forward)

3. Definição das camadas do MLP

Solução

Desafio: Criando um Perceptron

1. Inicialização dos parâmetros da camada (__init__)

2. Implementação da propagação direta (forward)

3. Definição das camadas do MLP

Solução

1. Inicialização dos parâmetros da camada (`init`)

2. Implementação da propagação direta (`forward`)

1. Inicialização dos parâmetros da camada (`init`)

2. Implementação da propagação direta (`forward`)