Modelos de lenguaje avanzados: guía completa

Los modelos de lenguaje avanzados han revolucionado el procesamiento del lenguaje natural. Esta guía explora las arquitecturas modernas y sus aplicaciones.

1. Arquitectura de los Transformers

Principios fundamentales

# Ejemplo de implementación simplificada de un Transformer
import torch
import torch.nn as nn

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        self.num_heads = num_heads
        self.d_model = d_model
        self.d_k = d_model // num_heads
        
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)
        
    def forward(self, query, key, value, mask=None):
        batch_size = query.size(0)
        
        # Proyecciones lineales
        Q = self.W_q(query).view(batch_size, -1, self.num_heads, self.d_k)
        K = self.W_k(key).view(batch_size, -1, self.num_heads, self.d_k)
        V = self.W_v(value).view(batch_size, -1, self.num_heads, self.d_k)
        
        # Cálculo de las puntuaciones de atención
        scores = torch.matmul(Q, K.transpose(-2, -1)) / torch.sqrt(torch.tensor(self.d_k))
        
        if mask is not None:
            scores = scores.masked_fill(mask == 0, float('-inf'))
            
        # Softmax y atención
        attention = torch.softmax(scores, dim=-1)
        context = torch.matmul(attention, V)
        
        # Concatenación y proyección final
        context = context.view(batch_size, -1, self.d_model)
        output = self.W_o(context)
        
        return output

2. Modelos preentrenados

Uso de BERT

# Ejemplo de uso de BERT para clasificación
from transformers import BertTokenizer, BertForSequenceClassification

# Carga del modelo
model_name = "bert-base-multilingual-cased"
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertForSequenceClassification.from_pretrained(model_name, num_labels=2)

# Preparación de los datos
text = "L'intelligence artificielle révolutionne le traitement du langage."
inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=512)

# Predicción
outputs = model(**inputs)
predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)

Fine-tuning de GPT

# Ejemplo de fine-tuning de GPT-2
from transformers import GPT2LMHeadModel, GPT2Tokenizer, TextDataset, DataCollatorForLanguageModeling
from transformers import Trainer, TrainingArguments

# Carga del modelo
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Preparación de los datos
def load_dataset(file_path, tokenizer):
    dataset = TextDataset(
        tokenizer=tokenizer,
        file_path=file_path,
        block_size=128
    )
    return dataset

# Configuración del entrenamiento
training_args = TrainingArguments(
    output_dir="./gpt2-finetuned",
    overwrite_output_dir=True,
    num_train_epochs=3,
    per_device_train_batch_size=4,
    save_steps=10000,
    save_total_limit=2,
)

# Entrenamiento
trainer = Trainer(
    model=model,
    args=training_args,
    data_collator=DataCollatorForLanguageModeling(tokenizer=tokenizer),
    train_dataset=load_dataset("train.txt", tokenizer)
)

trainer.train()

3. Aplicaciones avanzadas

Generación de texto creativo

# Ejemplo de generación de texto con GPT-3
from transformers import GPT2LMHeadModel, GPT2Tokenizer

def generate_creative_text(prompt, max_length=100):
    model = GPT2LMHeadModel.from_pretrained('gpt2')
    tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
    
    # Codificación del prompt
    inputs = tokenizer.encode(prompt, return_tensors='pt')
    
    # Generación con parámetros creativos
    outputs = model.generate(
        inputs,
        max_length=max_length,
        num_return_sequences=1,
        temperature=0.8,
        top_k=50,
        top_p=0.95,
        do_sample=True,
        pad_token_id=tokenizer.eos_token_id
    )
    
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

Análisis de sentimiento avanzado

# Ejemplo de análisis de sentimiento con RoBERTa
from transformers import RobertaTokenizer, RobertaForSequenceClassification

def analyze_sentiment_advanced(text):
    model_name = "roberta-base"
    tokenizer = RobertaTokenizer.from_pretrained(model_name)
    model = RobertaForSequenceClassification.from_pretrained(model_name, num_labels=3)
    
    # Preparación de los datos
    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
    
    # Predicción
    outputs = model(**inputs)
    predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
    
    # Interpretación de los resultados
    sentiment_scores = {
        "négatif": predictions[0][0].item(),
        "neutre": predictions[0][1].item(),
        "positif": predictions[0][2].item()
    }
    
    return sentiment_scores

4. Optimización y rendimiento

Cuantización del modelo

# Ejemplo de cuantización de un modelo
from transformers import AutoModelForSequenceClassification
import torch.quantization

def quantize_model(model_name):
    # Carga del modelo
    model = AutoModelForSequenceClassification.from_pretrained(model_name)
    
    # Preparación para la cuantización
    model.eval()
    model.qconfig = torch.quantization.get_default_qconfig('fbgemm')
    
    # Cuantización
    torch.quantization.prepare(model, inplace=True)
    torch.quantization.convert(model, inplace=True)
    
    return model

Optimización del rendimiento

# Ejemplo de optimización del rendimiento
from transformers import AutoModel, AutoTokenizer
import torch

def optimize_model_performance(model_name):
    # Carga del modelo
    model = AutoModel.from_pretrained(model_name)
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    
    # Optimizaciones
    model.eval()
    with torch.no_grad():
        # Ejemplo de batch processing
        texts = ["Premier texte.", "Deuxième texte.", "Troisième texte."]
        inputs = tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
        outputs = model(**inputs)
    
    return model, tokenizer

5. Buenas prácticas

Gestión de la memoria

# Ejemplo de gestión de la memoria
import torch
from transformers import AutoModel

def manage_memory(model_name):
    # Carga con gestión de memoria
    model = AutoModel.from_pretrained(
        model_name,
        device_map="auto",
        low_cpu_mem_usage=True
    )
    
    # Limpieza de la memoria
    def clear_memory():
        torch.cuda.empty_cache()
        import gc
        gc.collect()
    
    return model, clear_memory

Evaluación de los modelos

# Script de evaluación completo
def evaluate_language_model(model, tokenizer, test_data):
    model.eval()
    results = {
        "perplexity": 0,
        "accuracy": 0,
        "inference_time": 0
    }
    
    with torch.no_grad():
        for batch in test_data:
            start_time = time.time()
            
            # Predicción
            outputs = model(**batch)
            
            # Cálculo de las métricas
            results["perplexity"] += outputs.loss.item()
            results["inference_time"] += time.time() - start_time
    
    # Normalización de los resultados
    results["perplexity"] /= len(test_data)
    results["inference_time"] /= len(test_data)
    
    return results

Conclusión

Los modelos de lenguaje avanzados ofrecen capacidades impresionantes:

• Comprensión profunda del lenguaje
• Generación de texto creativo
• Análisis de sentimiento preciso
• Traducción de alta calidad
• Pregunta-respuesta avanzado

Puntos clave que recordar:

• Comprender la arquitectura de los Transformers
• Dominar los modelos preentrenados
• Optimizar el rendimiento
• Gestionar la memoria de forma eficiente
• Evaluar correctamente los resultados