Redes Neurais Recorrentes

🔤 Exemplo de Tokenização em Python

import tensorflow as tf

# Texto de exemplo
texto = "As redes neurais recorrentes são poderosas para NLP"

# Criar tokenizador ao nível de palavras
tokenizer = tf.keras.preprocessing.text.Tokenizer()
tokenizer.fit_on_texts([texto])

# Vocabulário aprendido
print("Vocabulário:", tokenizer.word_index)
# Saída: {'as': 1, 'redes': 2, 'neurais': 3, 'recorrentes': 4, 
#         'são': 5, 'poderosas': 6, 'para': 7, 'nlp': 8}

# Converter texto em sequência de índices
sequencia = tokenizer.texts_to_sequences([texto])
print("Sequência:", sequencia)
# Saída: [[1, 2, 3, 4, 5, 6, 7, 8]]

💻 Criando Embeddings com Keras

from tensorflow.keras.layers import Embedding
import tensorflow as tf

# Parâmetros
vocab_size = 10000  # Tamanho do vocabulário
embedding_dim = 128  # Dimensão dos embeddings
max_length = 50      # Comprimento máximo da sequência

# Criar camada de embedding
embedding_layer = Embedding(
    input_dim=vocab_size,      # Número de palavras únicas
    output_dim=embedding_dim,  # Dimensão de cada vetor de palavra
    input_length=max_length    # Tamanho fixo das sequências
)

# Exemplo: converter sequência de índices em embeddings
sequencia = tf.constant([[1, 5, 8, 3, 12]])  # Uma frase tokenizada
embeddings = embedding_layer(sequencia)

print(f"Forma dos embeddings: {embeddings.shape}")
# Saída: (1, 5, 128) - 1 frase, 5 palavras, 128 dimensões cada

🎲 Implementando Amostragem com Temperatura

import numpy as np

def sample_with_temperature(logits, temperature=1.0):
    """
    Amostra uma palavra usando temperatura.
    
    Args:
        logits: vetor de scores pré-softmax
        temperature: controla aleatoriedade (0 = determinístico, >1 = criativo)
    
    Returns:
        índice da palavra amostrada
    """
    # Aplicar temperatura
    logits = np.array(logits) / temperature
    
    # Aplicar softmax
    exp_logits = np.exp(logits - np.max(logits))  # Subtrair max para estabilidade numérica
    probabilities = exp_logits / np.sum(exp_logits)
    
    # Amostrar proporcionalmente às probabilidades
    return np.random.choice(len(logits), p=probabilities)

# Exemplo de uso
logits = [3.2, 2.5, 1.8, 1.0]  # Scores da rede para 4 palavras possíveis

print("Amostragem conservadora (T=0.5):")
for _ in range(5):
    idx = sample_with_temperature(logits, temperature=0.5)
    print(f"  Palavra selecionada: {idx}")

print("\nAmostragem criativa (T=1.5):")
for _ in range(5):
    idx = sample_with_temperature(logits, temperature=1.5)
    print(f"  Palavra selecionada: {idx}")

🐍 Instalação e Importação das Bibliotecas

# Instalar a biblioteca LIME
!pip install lime

📚 Importação das bibliotecas necessárias

import numpy as np
import matplotlib.pyplot as plt
from lime.lime_text import LimeTextExplainer
from tensorflow.keras.preprocessing.sequence import pad_sequences
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense

📝 Definindo o Texto Base (Corpus)

corpus = "Este é um exemplo de texto para treinar uma RNN."

💡 Nota: Em aplicações reais, o corpus seria muito maior (milhares ou milhões de palavras). Para demonstração, usamos um texto pequeno, mas o mesmo princípio se aplica.

🔤 Tokenização dos Caracteres

tokenizer = tf.keras.preprocessing.text.Tokenizer(char_level=True)
tokenizer.fit_on_texts([corpus])
sequence_data = tokenizer.texts_to_sequences([corpus])[0]
vocab_size = len(tokenizer.word_index) + 1

print(f"Tamanho do vocabulário: {vocab_size} caracteres únicos")

Explicação:

• char_level=True: Tokeniza ao nível de caractere, não de palavra
• fit_on_texts: Analisa o corpus e cria um mapeamento char → índice
• texts_to_sequences: Converte o texto em lista de índices
• +1: Reserva índice 0 para padding (opcional)

🔍 Resultado da tokenização:

print(corpus)
print(tokenizer.word_index)

📊 Preparando os Dados de Entrada e Saída

seq_length = 5  # Janela de contexto: 5 caracteres anteriores
sequences = []
for i in range(seq_length, len(sequence_data)):
    # Cria sequências de comprimento seq_length + 1
    # Primeiros 5: entrada, último: alvo (target)
    sequences.append(sequence_data[i-seq_length:i+1])

sequences = np.array(sequences)
X, y = sequences[:, :-1], sequences[:, -1]  # Separa entrada (X) e saída (y)

print(f"Forma de X: {X.shape}")  # (num_sequences, seq_length)
print(f"Forma de y: {y.shape}")  # (num_sequences,)

Sequência 1: X=[5,12,3,2,1] → y=13  (dado "Este ", prediz "é")
Sequência 2: X=[12,3,2,1,13] → y=...  (dado "ste é", prediz próximo char)

🏗️ Criando e Treinando o Modelo RNN (LSTM)

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Embedding

model = Sequential([
    # Embedding: Converte índices em vetores densos de dimensão 10
    # vocab_size: tamanho do vocabulário (número de caracteres únicos)
    # 10: dimensão do vetor embedding (cada caractere vira um vetor de 10 números)
    # input_length: comprimento das sequências de entrada
    Embedding(vocab_size, 10, input_length=seq_length),
    
    # LSTM: Camada recorrente com 50 unidades (neurônios)
    # return_sequences=False: retorna apenas o último output (não toda a sequência)
    # A LSTM mantém memória de curto e longo prazo através de gates
    LSTM(50, return_sequences=False),
    
    # Dense: Camada de saída com softmax
    # vocab_size neurônios, um para cada caractere possível
    # softmax: produz distribuição de probabilidade
    Dense(vocab_size, activation='softmax')
])

# Loss: sparse_categorical_crossentropy para classes representadas por índices
# Optimizer: adam (adaptativo, eficiente para RNNs)
model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')
model.summary()

Sequência de índices [5,12,3,2,1]  (shape: (5,))
         ↓ Embedding
Matriz de vetores [[0.1,...], [0.3,...], ...]  (shape: (5, 10))
         ↓ LSTM processa sequência
Vetor contextualizado [0.8, 0.2, ...]  (shape: (50,))
         ↓ Dense + Softmax
Probabilidades para cada char [0.05, 0.02, 0.41, ...]  (shape: (vocab_size,))

🎯 Treinamento do modelo:

# epochs=300: número de vezes que o modelo vê todo o dataset
# Para corpus pequeno, muitas epochs são necessárias para aprender padrões
# Para corpus grande, menos epochs são suficientes
history = model.fit(X, y, epochs=300, verbose=1)

📈 Visualizando a Curva de Aprendizado

import matplotlib.pyplot as plt

plt.figure(figsize=(10, 5))
plt.plot(history.history['loss'], linewidth=2, color='#3498db')
plt.title('Curva de Aprendizado: Loss ao Longo do Treinamento', fontsize=14, fontweight='bold')
plt.ylabel('Loss (Sparse Categorical Crossentropy)', fontsize=12)
plt.xlabel('Epoch', fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

✨ Gerando Texto com o Modelo Treinado

def gerar_texto(modelo, seed_text, next_chars, tokenizer, seq_length):
    """
    Gera texto caractere por caractere usando o modelo treinado.
    
    Parâmetros:
        modelo: modelo LSTM treinado
        seed_text: texto inicial (semente) com pelo menos seq_length caracteres
        next_chars: quantos caracteres gerar
        tokenizer: tokenizer usado no treinamento
        seq_length: tamanho da janela de contexto
    
    Retorna:
        Texto gerado (seed_text + caracteres gerados)
    """
    result = seed_text
    
    for _ in range(next_chars):
        # 1. Tokeniza o seed_text atual
        encoded = tokenizer.texts_to_sequences([seed_text])[0]
        
        # 2. Pega apenas os últimos seq_length caracteres (janela deslizante)
        encoded = np.array(encoded[-seq_length:]).reshape(1, seq_length)
        
        # 3. Prediz probabilidades para o próximo caractere
        predicted_probs = modelo.predict(encoded, verbose=0)
        
        # 4. Escolhe o caractere com maior probabilidade (greedy)
        predicted_idx = np.argmax(predicted_probs, axis=-1)
        
        # 5. Converte índice de volta para caractere
        out_char = tokenizer.sequences_to_texts([[predicted_idx[0]]])[0]
        
        # 6. Adiciona ao seed e ao resultado
        seed_text += out_char
        result += out_char
    
    return result

seed_text = "Este "  (5 caracteres)
encoded = [5, 12, 3, 2, 1]
predicted_probs = [0.01, 0.87, 0.03, ...]  ← índice 1 tem 87% de probabilidade
out_char = 'é'
seed_text = "Este é"

seed_text = "Este é"  (6 caracteres, pega últimos 5)
encoded = [12, 3, 2, 1, 13]  ← últimos 5
predicted_probs = [0.02, 0.05, 0.72, ...]  ← índice 2 tem 72%
out_char = ' '
seed_text = "Este é "

🎪 Testando a Geração de Texto

# Usando "Este " como semente (5 caracteres)
seed_text = "Este "
generated = gerar_texto(model, seed_text, 43, tokenizer, seq_length)
print("Texto gerado:", generated)

Texto gerado: Este é um exemplo de texto para treinar uma RNN.

# Teste com seed diferente
print(gerar_texto(model, "exem", 20, tokenizer, seq_length))
# Pode gerar: "exemplo de texto para"

# Seed que não está no corpus
print(gerar_texto(model, "Rede ", 15, tokenizer, seq_length))
# Resultado pode ser menos coerente (generalização limitada)

🔬 Interpretando o Modelo com LIME

LIME (Local Interpretable Model-agnostic Explanations) é uma técnica que explica quais partes do texto mais influenciam as predições do modelo. Útil para entender o comportamento da RNN e debugar problemas.

from lime.lime_text import LimeTextExplainer
from tensorflow.keras.preprocessing.sequence import pad_sequences

def predict_proba(texts):
    """
    Função wrapper para LIME: converte textos em predições.
    
    LIME precisa de uma função que:
        - Recebe: lista de strings
        - Retorna: matriz de probabilidades (n_samples, n_classes)
    """
    # Tokeniza os textos perturbados
    sequences = tokenizer.texts_to_sequences(texts)
    
    # Padding: garante que todas as sequências tenham seq_length
    # padding='pre': adiciona zeros no início se necessário
    padded_sequences = pad_sequences(sequences, maxlen=seq_length, padding='pre')
    
    # Prediz probabilidades para cada classe (caractere)
    predictions = model.predict(padded_sequences, verbose=0)
    
    return predictions

🔍 Aplicando o LIME ao Texto Gerado

# Cria o explicador
# class_names: nomes das classes (aqui são os índices dos caracteres)
explainer = LimeTextExplainer(class_names=[str(i) for i in range(vocab_size)])

# Explica a predição para o texto gerado
# generated: texto a ser explicado
# predict_proba: função que faz predições
# num_features: quantas features (caracteres) mostrar na explicação
explanation = explainer.explain_instance(
    generated, 
    predict_proba, 
    num_features=len(generated),
    num_samples=500  # Número de perturbações para testar
)

# Mostra a explicação visual (em notebook)
explanation.show_in_notebook(text=True)

# Ou salva como HTML
explanation.save_to_file('lime_explanation.html')

Texto: "Este é um exemplo"
Predição: próximo caractere = ' ' (espaço)

LIME pode revelar:
- Palavra "exemplo" tem forte influência positiva (geralmente seguida de espaço)
- Letra "o" final tem alta importância
- Contexto "um exemplo" é determinante

📋 Código Completo - Gerador de Texto com LSTM

Código completo e funcional para copiar e executar:

import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Embedding
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from lime.lime_text import LimeTextExplainer

# ===== 1. PREPARAÇÃO DOS DADOS =====
corpus = "Este é um exemplo de texto para treinar uma RNN."
tokenizer = Tokenizer(char_level=True)
tokenizer.fit_on_texts([corpus])
sequence_data = tokenizer.texts_to_sequences([corpus])[0]
vocab_size = len(tokenizer.word_index) + 1

# Cria sequências de treinamento
seq_length = 5
sequences = []
for i in range(seq_length, len(sequence_data)):
    sequences.append(sequence_data[i-seq_length:i+1])

sequences = np.array(sequences)
X, y = sequences[:, :-1], sequences[:, -1]

# ===== 2. CONSTRUÇÃO DO MODELO =====
model = Sequential([
    Embedding(vocab_size, 10, input_length=seq_length),
    LSTM(50, return_sequences=False),
    Dense(vocab_size, activation='softmax')
])

model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')
print(model.summary())

# ===== 3. TREINAMENTO =====
history = model.fit(X, y, epochs=300, verbose=1)

# Plot da loss
plt.figure(figsize=(8, 4))
plt.plot(history.history['loss'])
plt.title('Curva de Aprendizado')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.grid(True)
plt.show()

# ===== 4. GERAÇÃO DE TEXTO =====
def gerar_texto(modelo, seed_text, next_chars, tokenizer, seq_length):
    result = seed_text
    for _ in range(next_chars):
        encoded = tokenizer.texts_to_sequences([seed_text])[0]
        encoded = np.array(encoded[-seq_length:]).reshape(1, seq_length)
        predicted_probs = modelo.predict(encoded, verbose=0)
        predicted_idx = np.argmax(predicted_probs, axis=-1)
        out_char = tokenizer.sequences_to_texts([[predicted_idx[0]]])[0]
        seed_text += out_char
        result += out_char
    return result

# Teste da geração
seed_text = "Este "
generated = gerar_texto(model, seed_text, 43, tokenizer, seq_length)
print(f"\nTexto gerado:\n{generated}")

# ===== 5. INTERPRETAÇÃO COM LIME =====
def predict_proba(texts):
    sequences = tokenizer.texts_to_sequences(texts)
    padded_sequences = pad_sequences(sequences, maxlen=seq_length, padding='pre')
    predictions = model.predict(padded_sequences, verbose=0)
    return predictions

explainer = LimeTextExplainer(class_names=[str(i) for i in range(vocab_size)])
explanation = explainer.explain_instance(
    generated, 
    predict_proba, 
    num_features=len(generated),
    num_samples=500
)

# Salva explicação
explanation.save_to_file('lime_explanation.html')
print("\nExplicação LIME salva em 'lime_explanation.html'")

pip install tensorflow numpy matplotlib lime

⚡ Fatos Técnicos Interessantes