NeuralMath

Funções de ativação

A implementação começa pelas duas não linearidades usadas pela rede. A ReLU atua na camada oculta; a sigmoide transforma o escore final em um valor entre 0 e 1.

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

def relu_derivative(s):
    return (s > 0).astype(float)

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

Construção de um conjunto sintético amplo

Usamos massa e diâmetro como duas características físicas. Os dados são sintéticos, mas permanecem em faixas plausíveis para o exemplo didático. Uma curva suave de referência é usada apenas para gerar uma geometria não trivial; a rede nunca recebe essa curva.

def base_boundary(m):
    return (
        6.68
        + 0.74 * np.exp(-((m - 155) / 20) ** 2)
        + 1.50 / (1 + np.exp(-(m - 202) / 5))
    )

X_train = np.vstack([apple_1, apple_2, orange_1, orange_2])
y_train = np.array([1.0] * 32 + [0.0] * 32)

Padronização das entradas

Massa e diâmetro possuem escalas numéricas diferentes. A média e o desvio-padrão são calculados apenas com o conjunto de treinamento e reutilizados de forma consistente em todo o experimento.

mean = X_train.mean(axis=0)
std = X_train.std(axis=0)
Xn = (X_train - mean) / std

Inicialização de uma rede 2–12–1

O modelo possui duas entradas, doze neurônios ReLU na camada oculta e uma saída sigmoide. Isso totaliza 49 parâmetros treináveis, mantendo a rede pequena o bastante para ser inspecionada linha por linha.

rng = np.random.default_rng(42)
W1 = 0.1 * rng.standard_normal((12, 2))
b1 = np.zeros(12)
W2 = 0.1 * rng.standard_normal(12)
b2 = 0.0

Propagação direta

Uma previsão é apenas uma sequência de transformações afins e funções de ativação. Estas quatro linhas formam o núcleo computacional da inferência.

z1 = W1 @ x + b1
h = relu(z1)
z2 = W2 @ h + b2
y_hat = sigmoid(z2)

Retropropagação

As derivadas aparecem explicitamente. Não há diferenciação automática: a regra da cadeia está escrita diretamente no código, que é o principal objetivo pedagógico deste exemplo.

delta2 = (y_hat - target) * y_hat * (1 - y_hat)
dW2 = delta2 * h
db2 = delta2

delta1 = (delta2 * W2) * relu_derivative(z1)
dW1 = np.outer(delta1, x)
db1 = delta1

Descida do gradiente estocástica

A cada época os exemplos são embaralhados e os parâmetros são atualizados após cada observação. O procedimento utiliza repetidamente os gradientes calculados acima para reduzir a perda.

for epoch in range(n_epochs):
    for i in rng.permutation(len(Xn)):
        # forward pass and backpropagation
        W1 -= learning_rate * dW1
        b1 -= learning_rate * db1
        W2 -= learning_rate * dW2
        b2 -= learning_rate * db2

O que o treinamento produz

Com a semente aleatória e os hiperparâmetros fixados neste exemplo, a pequena rede classifica os 64 exemplos de treinamento e os 8 exemplos de teste ilustrativo de acordo com os rótulos definidos para o experimento sintético.

Final mean loss: 0.0001785644
Training accuracy: 1.0000
Illustrative test accuracy: 1.0000

Test outputs:
[121.0, 7.20] -> 0.999927 -> apple
[135.0, 7.45] -> 0.999900 -> apple
[152.0, 7.75] -> 0.999780 -> apple
[171.0, 7.32] -> 0.986972 -> apple
[121.0, 6.28] -> 0.000019 -> orange
[152.0, 6.86] -> 0.000009 -> orange
[189.0, 6.48] -> 0.000028 -> orange
[208.0, 7.55] -> 0.014957 -> orange

Construção da fronteira de decisão

Depois do treinamento, a rede é avaliada em uma grade densa. O nível y-hat = 0,5 torna-se a fronteira de decisão aprendida e revela a geometria não linear construída pela camada oculta.

masses = np.linspace(116, 214, 500)
diameters = np.linspace(6.0, 8.85, 500)
M, D = np.meshgrid(masses, diameters)
grid = np.column_stack([M.ravel(), D.ravel()])
P = predict(grid, mean, std, W1, b1, W2, b2).reshape(M.shape)

ax.contour(M, D, P, levels=[0.5], linewidths=2.2)

Recursos completos

Os scripts completos, notebooks e saídas reproduzíveis estão disponíveis abaixo. O código mostrado em todas as versões linguísticas utiliza os mesmos identificadores canônicos em inglês, evitando que o programa executável se fragmente entre traduções.

Python sourceGitHub repositoryGoogle ColabFigure (PDF)

Extensões futuras

NeuralMath foi pensado para crescer como uma sequência de exemplos computacionais, e não como uma coleção de páginas desconectadas. Entre as extensões planejadas estão dinâmica do treinamento, visualização da contribuição dos neurônios ocultos, verificação de gradientes, classificação multiclasse com softmax, redes mais profundas e pequenos experimentos interativos no navegador.

Sobre o autor

Americo Cunha Jr é cientista computacional, pesquisador do Laboratório Nacional de Computação Científica (LNCC) e professor associado da Universidade do Estado do Rio de Janeiro (UERJ). Sua pesquisa situa-se na interface entre dinâmica não linear, modelagem matemática e computacional, quantificação de incertezas, problemas inversos e inteligência artificial/aprendizado de máquina científico. Recebeu o Prêmio ABMEC para Jovens Cientistas em 2023 e mantém atuação editorial e colaborações científicas internacionais.

americocunha.orgORCIDGoogle Scholar

Licença

Salvo indicação em contrário, o texto explicativo do website e as figuras originais do site são disponibilizados sob a licença Creative Commons Atribuição 4.0 Internacional (CC BY 4.0). O PDF didático poderá estar sujeito à licença da versão publicada pela revista. O código-fonte é distribuído separadamente e deve possuir uma licença própria para software.