Neste momento, queremos construir uma rede neural com um único neurônio. Como exemplo, vamos utilizá-lo em uma tarefa de classificação binária, como detecção de spam, onde 0 representa um e-mail legítimo (não-spam) e 1 representa um e-mail de spam.

O neurônio receberá características numéricas relacionadas aos e-mails como entradas e produzirá uma saída entre 0 e 1, representando a probabilidade de um e-mail ser spam.

Veja o que acontece passo a passo:

1. Cada entrada é multiplicada por um peso correspondente. Os pesos são parâmetros ajustáveis que determinam a importância de cada entrada;
2. Todas as entradas ponderadas são somadas;
3. Um parâmetro adicional chamado viés é adicionado à soma das entradas. O viés permite que o neurônio desloque sua saída para cima ou para baixo, proporcionando flexibilidade ao modelo;
4. A soma das entradas é então passada por uma função de ativação. Como temos apenas um único neurônio, que produz diretamente a saída final (uma probabilidade), utilizaremos a função sigmoide, que comprime os valores no intervalo $(0, 1)$.

Classe Neuron

Um neurônio precisa armazenar seus pesos e bias, tornando a classe uma forma natural de agrupar essas propriedades relacionadas.

class Neuron:
    def __init__(self, n_inputs):  
        self.weights = ...
        self.bias = ...

• weights: uma lista de valores inicializados aleatoriamente que determinam a importância de cada entrada (n_inputs é o número de entradas) para o neurônio;
• bias: um valor inicializado aleatoriamente que auxilia o neurônio a tomar decisões flexíveis.

Os pesos e o bias devem ser inicializados aleatoriamente com valores pequenos entre -1 e 1, extraídos de uma distribuição uniforme, para quebrar a simetria e garantir que diferentes neurônios aprendam características distintas.

Para recapitular, o NumPy fornece a função random.uniform() para gerar um número aleatório ou um array (especificando o argumento size) de números aleatórios de uma distribuição uniforme dentro do intervalo [low, high).

import numpy as np

np.random.uniform(low, high, size=...)

Propagação Direta

Além disso, a classe Neuron deve incluir um método activate(), que calcula a soma ponderada das entradas e aplica a função de ativação (sigmoide, no nosso caso).

Na verdade, se tivermos dois vetores de mesmo comprimento (weights e inputs), a soma ponderada pode ser calculada utilizando o produto escalar desses vetores:

Isso nos permite calcular a soma ponderada em uma única linha de código usando a função numpy.dot(), eliminando a necessidade de um loop. O bias pode então ser adicionado diretamente ao resultado para obter input_sum_with_bias. A saída é então calculada aplicando a função de ativação sigmoide:

def activate(self, inputs):
    input_sum_with_bias = ...
    output = ...

    return output

Funções de Ativação

A fórmula para a função sigmoide é a seguinte, considerando que $z$ representa a soma ponderada das entradas com o viés adicionado (valor bruto de saída) para este neurônio específico:

Utilizando esta fórmula, a sigmoide pode ser implementada como uma função simples em Python:

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

A fórmula para a função ReLU é a seguinte, que basicamente define a saída igual a $z$ se for positiva e 0 caso contrário:

def relu(z):
    return np.maximum(0, z)