output = self.linear(hidden[-1])
import torch
import torch.nn as nn
--------------------------------------------------
Configuração do dispositivo
--------------------------------------------------
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
--------------------------------------------------
Classe da rede
Exemplo: classificação de sequências com Embedding + GRU
--------------------------------------------------
class GRUClassifier(nn.Module):
def init(self, vocab_size, tam_embedding, hidden_size, num_classes):
super(GRUClassifier, self).init()
# Salva tamanho do estado oculto
self.hidden_size = hidden_size
# Camada de embedding
# Converte índices de tokens em vetores densos
self.embedding = nn.Embedding(vocab_size, tam_embedding)
# GRU com 2 camadas
# input_size = tam_embedding
# hidden_size = hidden_size
# num_layers = 2
self.rnn = nn.GRU(
input_size=tam_embedding,
hidden_size=hidden_size,
num_layers=2
)
# Camada linear final para classificação
self.linear = nn.Linear(hidden_size, num_classes)
def forward(self, X):
"""
X: tensor de índices com shape (seq_len, batch_size)
"""
# ------------------------------------------
# 1) Embedding
# Entrada: (S, B)
# Saída: (S, B, E)
# ------------------------------------------
emb = self.embedding(X)
# ------------------------------------------
# 2) Inicialização do hidden state
# Shape: (num_layers, batch_size, hidden_size)
# Como temos 2 camadas:
# hidden -> (2, B, H)
# ------------------------------------------
hidden = torch.zeros(2, X.size(1), self.hidden_size).to(device)
# ------------------------------------------
# 3) Forward na GRU
# saida -> (S, B, H)
# hidden -> (2, B, H)
# ------------------------------------------
saida, hidden = self.rnn(emb, hidden)
# ------------------------------------------
# 4) Pegar a memória da ÚLTIMA camada
# hidden[-1] -> (B, H)
# Isso é o que vai para a camada linear
# ------------------------------------------
output = self.linear(hidden[-1])
return output
--------------------------------------------------
Exemplo de uso
--------------------------------------------------
if name == "main":
# Parâmetros do exemplo
vocab_size = 1000 # tamanho do vocabulário
tam_embedding = 50 # dimensão do embedding
hidden_size = 256 # tamanho da feature oculta
num_classes = 3 # número de classes
seq_len = 12 # tamanho da sequência
batch_size = 64 # tamanho do batch
# Instancia o modelo
model = GRUClassifier(
vocab_size=vocab_size,
tam_embedding=tam_embedding,
hidden_size=hidden_size,
num_classes=num_classes
).to(device)
# Exemplo de entrada:
# tensor de índices inteiros no formato (seq_len, batch_size)
X = torch.randint(0, vocab_size, (seq_len, batch_size)).to(device)
# Forward
y_pred = model(X)
# Mostra shapes importantes
print("Entrada X:", X.shape) # (12, 64)
print("Saída final:", y_pred.shape) # (64, 3)
