Arquivo de AM Supervisionado - Página 21 de 25

1.1 – Regressao
1.1.7 – Redes Neurais – Deep Learning
1.1.7.1 – Perceptron Multicamadas – MLP/FNN

LEGENDA

Principal

Ramo

Metodo

Problemas

Modelo

Arquitetura

a arquitetura mais fundamental do deep learning

O Perceptron Multicamadas (MLP) é a arquitetura neural mais básica e fundamental do deep learning. Ela consiste em uma camada de entrada, uma ou mais camadas ocultas e uma camada de saída. Cada neurônio de uma camada conecta-se a todos os neurônios da camada seguinte. Por exemplo, para classificar dígitos, a entrada são pixels e a saída são 10 classes. Primeiramente, essa arquitetura totalmente conectada (fully connected) processa informações sequencialmente. Além disso, é também chamada de Rede Neural Feedforward (FNN). MLPs formam a base para arquiteturas mais complexas como CNNs e Transformers.

como os dados fluem pela rede

O fluxo de informações em um MLP ocorre apenas em uma direção: da entrada para a saída. Primeiramente, os dados entram pela camada de entrada, onde cada neurônio representa uma característica. Depois, os valores seguem para a primeira camada oculta através de conexões ponderadas. Cada neurônio oculto soma suas entradas ponderadas e aplica uma função de ativação. Esse processo se repete camada por camada até alcançar a camada de saída. Além disso, não há conexões retroalimentadas ou loops na arquitetura. Esse fluxo unidirecional dá origem ao nome “feedforward” (alimentação para frente).

aprendendo com retropropagação

O treinamento de MLPs utiliza o algoritmo de retropropagação (backpropagation) combinado com gradiente descendente. Primeiramente, fazemos uma passagem forward para calcular a saída da rede. Depois, calculamos o erro comparando a saída com o valor desejado. Além disso, propagamos esse erro de volta pelas camadas, ajustando os pesos. O gradiente indica em que direção modificar cada peso para reduzir o erro. Esse processo repete-se por muitas épocas até o erro convergir. A retropropagação é o algoritmo que permite que redes profundas aprendam.

camadas ocultas e capacidade de representação

As camadas ocultas são responsáveis pela capacidade do MLP de aprender padrões complexos. Primeiramente, camadas ocultas permitem que a rede aprenda representações intermediárias dos dados. Uma única camada oculta pode aproximar qualquer função contínua (teorema da aproximação universal). Além disso, múltiplas camadas ocultas permitem aprender hierarquias de características progressivamente. Por exemplo, em imagens, primeiras camadas detectam bordas, camadas posteriores reconhecem objetos. O número de neurônios por camada controla a capacidade de aprendizado. Mais neurônios aumentam o poder, mas também o risco de sobreajuste.

aplicações e limitações do mlp

MLPs são amplamente utilizados em problemas com dados tabulares estruturados. Primeiramente, sistemas financeiros usam MLPs para previsão de séries temporais e risco. Além disso, problemas de classificação com características bem definidas frequentemente usam MLPs. Na bioinformática, MLPs ajudam a prever estruturas de proteínas e interações. Entretanto, MLPs não capturam padrões espaciais (como imagens) ou sequenciais (como texto) de forma eficiente. Para esses casos, arquiteturas especializadas como CNNs e RNNs são mais adequadas. Para iniciantes, MLPs oferecem a introdução perfeita ao universo do deep learning. É o primeiro passo para entender redes neurais mais avançadas.

1.1 – Regressao
1.1.7 – Redes Neurais – Deep Learning
1.1.7.1 – Perceptron Multicamadas – MLP/FNN

LEGENDA

Principal

Ramo

Metodo

Problemas

Modelo

Arquitetura

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.

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()

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.