Neste exemplo, o objetivo é construir uma rede neural com um único neurônio. Ela será utilizada para uma tarefa de classificação binária, como detecção de spam, onde 0 corresponde a um e-mail legítimo (não-spam) e 1 corresponde a um e-mail de spam.

O neurônio receberá características numéricas extraídas dos e-mails como entradas e produzirá uma saída entre 0 e 1, representando a probabilidade de que um determinado e-mail seja 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 termo de viés é adicionado à soma das entradas, permitindo que o neurônio desloque sua saída e forneça flexibilidade adicional ao modelo;
4. A soma é passada por uma função de ativação. Como um único neurônio produz diretamente a saída final (uma probabilidade), a função sigmoide é utilizada para comprimir os valores no intervalo $(0, 1)$.

Classe Neurônio

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

A classe Neuron deve incluir um método activate() que calcula a soma ponderada das entradas e, em seguida, aplica a função de ativação (neste caso, a função sigmoide).

Quando dois vetores de mesmo comprimento — weights e inputs — estão disponíveis, a soma ponderada pode ser calculada de forma eficiente utilizando o produto escalar desses vetores.

Isso 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 sigmoid é 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:

Utilizando esta fórmula, a sigmoid 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)