O que é regressão com perceptron multicamadas
A regressão com redes neurais é um método poderoso. Ela usa uma arquitetura chamada perceptron multicamadas (MLP). Diferentemente da árvore, a MLP aprende funções suaves e complexas. Por exemplo, podemos prever o consumo de energia elétrica. A rede é composta por neurônios artificiais interconectados. Cada neurônio aplica uma transformação matemática simples. Essa transformação é frequentemente não linear. O aprendizado ocorre por meio de um processo chamado retropropagação. Iniciantes podem pensar na MLP como um “matemático universal”.
As características principais incluem flexibilidade e capacidade de generalização. Primeiramente, a MLP pode aproximar qualquer função contínua. Além disso, ela lida bem com dados de alta dimensionalidade. Contudo, seu treinamento pode ser mais demorado. A interpretabilidade é menor em comparação com árvores. Por essa razão, é importante entender sua arquitetura. Modelos bem ajustados produzem predições precisas e estáveis. Eles são amplamente usados em problemas do mundo real.
Arquitetura da rede neural
A arquitetura MLP possui três tipos de camadas. A camada de entrada recebe as características dos dados. Cada característica é conectada a todos os neurônios seguintes. Em seguida, vêm uma ou mais camadas ocultas. Cada camada oculta contém neurônios com funções de ativação. Finalmente, a camada de saída produz o valor numérico previsto. Para regressão, essa camada usa ativação linear. O número de neurônios ocultos é um hiperparâmetro crucial. Redes mais largas e profundas são mais expressivas.
Uma fórmula descreve a operação de um neurônio. Primeiro, calcula-se a soma ponderada das entradas: \(z = \sum_{i=1}^{n} w_i x_i + b\). Depois, aplica-se a função de ativação \(a = f(z)\). Funções comuns são ReLU, tangente hiperbólica e sigmoide. A ReLU é definida como \(f(z) = \max(0, z)\). Ela é frequentemente usada em camadas ocultas. A saída final da rede é uma combinação linear dessas ativações. Todo esse processamento é feito simultaneamente para todos os dados.
Hiperparâmetros importantes
Os hiperparâmetros controlam o treinamento da MLP. A taxa de aprendizado define o tamanho dos passos de ajuste. O número de épocas é quantas vezes vemos todos os dados. O tamanho do lote (batch) afeta a estabilidade do gradiente. A escolha da função de ativação impacta a convergência. Além disso, a regularização evita overfitting. Ela é aplicada por meio de penalidades nos pesos. A inicialização dos pesos também é um fator relevante. Esses parâmetros são ajustados empiricamente.
Uma fórmula central é a da retropropagação do erro. O erro quadrático médio é frequentemente minimizado: \(MSE = \frac{1}{N}\sum_{i=1}^{N} (y_i – \hat{y}_i)^2\). A atualização dos pesos segue a regra do gradiente descendente: \(w_{novo} = w_{velho} – \eta \frac{\partial MSE}{\partial w}\). Nessa equação, \(\eta\) é a taxa de aprendizado. O gradiente é calculado pela regra da cadeia. Esse processo é repetido até a convergência do erro. Sem ajuste cuidadoso, a rede pode não aprender corretamente.
Exemplo prático em Python
O código abaixo deve ser executado no Google Colab. Ele cria dados sintéticos com ruído e uma tendência cúbica. Uma MLP com uma camada oculta é treinada para regressão. O gráfico mostra os dados reais e a predição da rede. Certifique-se de ter as bibliotecas instaladas. A seguir, o código completo é apresentado.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
import numpy as np import matplotlib.pyplot as plt from sklearn.neural_network import MLPRegressor from sklearn.preprocessing import StandardScaler # Dados sintéticos: y = x^3 + ruído np.random.seed(42) X = np.sort(5 * np.random.rand(200, 1), axis=0) y = (X ** 3).ravel() + np.random.normal(0, 2, X.shape[0]) # Normalização é recomendada para MLPs scaler_X = StandardScaler() scaler_y = StandardScaler() X_scaled = scaler_X.fit_transform(X) y_scaled = scaler_y.fit_transform(y.reshape(-1, 1)).ravel() # MLP com uma camada oculta de 100 neurônios regressor = MLPRegressor(hidden_layer_sizes=(100,), activation='relu', learning_rate_init=0.01, max_iter=1000, random_state=42) regressor.fit(X_scaled, y_scaled) # Predição para valores suaves X_test = np.arange(0, 5, 0.01).reshape(-1, 1) X_test_scaled = scaler_X.transform(X_test) y_pred_scaled = regressor.predict(X_test_scaled) y_pred = scaler_y.inverse_transform(y_pred_scaled.reshape(-1, 1)) # Gráfico plt.figure(figsize=(10, 6)) plt.scatter(X, y, s=15, label="Dados reais", color="blue", alpha=0.6) plt.plot(X_test, y_pred, label="Predição da MLP", color="red", linewidth=2) plt.xlabel("Característica X") plt.ylabel("Alvo y") plt.title("Regressão com Perceptron Multicamadas") plt.legend() plt.grid(True) plt.show() |
A normalização dos dados é aplicada antes do treinamento. Ela é necessária porque redes neurais são sensíveis a escalas. A MLP usada tem 100 neurônios em uma camada oculta. A função ReLU é escolhida para evitar gradientes desvanecentes. O gráfico final mostra uma curva suave ajustada aos dados. Diferentemente da árvore, não há degraus visíveis. Isso demonstra a natureza contínua da regressão neural. Para melhores resultados, experimente mais neurônios ou camadas. Ajustar hiperparâmetros é uma prática comum e recomendada.