Click here to view the next lesson.

Capítulo 5: Modelos de Transformadores Clave e Innovaciones

5.1 BERT y sus Variantes (RoBERTa, DistilBERT)

La arquitectura Transformer ha revolucionado el campo del procesamiento del lenguaje natural (PLN) al permitir el desarrollo de modelos cada vez más sofisticados. Estas innovaciones han cambiado fundamentalmente la forma en que procesamos y entendemos el lenguaje humano. El mecanismo de atención de la arquitectura y sus capacidades de procesamiento paralelo han generado numerosos modelos especializados, cada uno diseñado para sobresalir en tareas específicas de PLN. Los investigadores y desarrolladores ahora tienen acceso a un poderoso conjunto de herramientas de modelos preentrenados que pueden adaptarse para aplicaciones específicas, desde la simple clasificación de texto hasta complejas tareas de generación de lenguaje.

El panorama de los modelos basados en Transformer es rico y diverso, con cada modelo aportando fortalezas únicas. Algunos se centran en la eficiencia computacional, otros en la precisión, y otros en tareas específicas de comprensión del lenguaje. Estos modelos se han convertido en herramientas esenciales en el PLN moderno, permitiendo mejoras revolucionarias en áreas como la traducción automática, el resumen de textos y la respuesta a preguntas. En este capítulo, exploraremos estos modelos clave basados en Transformer, examinando sus innovaciones arquitectónicas, aplicaciones prácticas y contribuciones significativas al campo.

Comenzaremos nuestra exploración con BERT (Representaciones Codificadoras Bidireccionales de Transformers), un modelo revolucionario que cambió el panorama del PLN. Junto con sus variantes notables, RoBERTa y DistilBERT, BERT introdujo varias innovaciones clave. Estas incluyen la capacidad de entender el contexto en ambas direcciones (procesamiento bidireccional), técnicas sofisticadas de preentrenamiento y métodos eficientes de ajuste fino. Estas capacidades han llevado a mejoras notables en varias tareas de PLN, desde el análisis de sentimientos hasta el reconocimiento de entidades nombradas. La capacidad de los modelos para capturar la comprensión matizada del lenguaje ha establecido nuevos estándares de rendimiento en numerosos puntos de referencia y aplicaciones del mundo real.

Empecemos profundizando en los detalles de BERT y su familia extendida de modelos, explorando cómo estas innovaciones trabajan juntas para crear sistemas de procesamiento del lenguaje más potentes y eficientes.

5.1.1 Introducción a BERT

BERT, introducido por Google AI en 2018, significa Representaciones Codificadoras Bidireccionales de Transformers. Este modelo revolucionario representó un avance significativo en el procesamiento del lenguaje natural. A diferencia de los modelos tradicionales que procesan el texto de manera secuencial o desde una única dirección (por ejemplo, de izquierda a derecha), BERT captura el contexto bidireccionalmente, considerando tanto las palabras precedentes como las siguientes en una secuencia. Esto significa que al procesar una palabra en una oración, BERT analiza simultáneamente tanto las palabras que vienen antes como después, lo que lleva a una comprensión mucho más rica del contexto y significado.

Por ejemplo, en la oración "El banco está junto al río", BERT puede entender que "banco" se refiere a la orilla del río y no a una institución financiera al analizar tanto "río" (que viene después) como "el" (que viene antes). Este análisis bidireccional representa una mejora significativa sobre los modelos anteriores que solo podían procesar texto en una dirección.

Este enfoque sofisticado permite a BERT generar incrustaciones contextualmente más ricas - representaciones numéricas de palabras que capturan su significado y relaciones con otras palabras. Como resultado, BERT ha demostrado ser excepcionalmente efectivo para una amplia gama de tareas de procesamiento del lenguaje natural. Sobresale particularmente en:

Respuesta a preguntas: Comprensión de consultas complejas y búsqueda de respuestas relevantes en el texto
Análisis de sentimientos: Determinación precisa del tono emocional y la opinión en el texto
Reconocimiento de entidades nombradas: Identificación y clasificación de información clave como nombres, ubicaciones y organizaciones en el texto

5.1.2 Innovaciones Fundamentales de BERT

Contexto Bidireccional

BERT utiliza el modelado de lenguaje enmascarado (MLM) para preentrenar en contexto bidireccional, lo que representa un avance significativo en el procesamiento del lenguaje natural. Esta capacidad bidireccional significa que el modelo puede procesar y comprender palabras simultáneamente analizando tanto su contexto precedente como siguiente en una oración. Durante el entrenamiento, BERT enmascara (oculta) aleatoriamente algunas palabras en el texto de entrada y aprende a predecir estas palabras enmascaradas basándose en el contexto circundante.

Este enfoque difiere fundamentalmente de modelos anteriores como GPT que solo podían procesar texto de izquierda a derecha, mirando las palabras anteriores para predecir la siguiente. La limitación de los modelos unidireccionales es que pierden contexto crucial que podría aparecer más adelante en la oración.

Por ejemplo, considere la oración "La orilla del río está lodosa". En este caso, el procesamiento bidireccional de BERT le permite:

Mirar hacia adelante para ver "lodosa" y "río"
Mirar hacia atrás para entender el contexto de "La"
Combinar estas pistas contextuales para determinar con precisión que "orilla" se refiere a la ribera del río y no a una institución financiera

Esta sofisticada comprensión bidireccional permite a BERT capturar matices complejos del lenguaje y relaciones entre palabras, independientemente de su posición en la oración. Como resultado, BERT puede manejar palabras y frases ambiguas de manera más efectiva, lo que lleva a interpretaciones del lenguaje mucho más precisas y matizadas. Esto es particularmente valioso en tareas que requieren una comprensión contextual profunda, como la desambiguación, el análisis de sentimientos y la respuesta a preguntas.

Ejemplo de Código: Demostrando el Contexto Bidireccional de BERT

from transformers import BertTokenizer, BertForMaskedLM
import torch

# Initialize tokenizer and model
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForMaskedLM.from_pretrained('bert-base-uncased')

# Example sentence with masked token
text = "The [MASK] bank is near the river."

# Tokenize input
inputs = tokenizer(text, return_tensors="pt")

# Get the position of the masked token
mask_token_index = torch.where(inputs["input_ids"] == tokenizer.mask_token_id)[1]

# Get model predictions
with torch.no_grad():
    outputs = model(**inputs)
    predictions = outputs.logits

# Get the predicted token
predicted_token_id = predictions[0, mask_token_index].argmax(axis=-1)
predicted_token = tokenizer.decode(predicted_token_id)

print(f"Original text: {text}")
print(f"Predicted word: {predicted_token}")

# Try another context
text_2 = "I need to deposit money at the [MASK] bank."
inputs_2 = tokenizer(text_2, return_tensors="pt")
mask_token_index_2 = torch.where(inputs_2["input_ids"] == tokenizer.mask_token_id)[1]

with torch.no_grad():
    outputs_2 = model(**inputs_2)
    predictions_2 = outputs_2.logits

predicted_token_id_2 = predictions_2[0, mask_token_index_2].argmax(axis=-1)
predicted_token_2 = tokenizer.decode(predicted_token_id_2)

print(f"\nOriginal text: {text_2}")
print(f"Predicted word: {predicted_token_2}")

Desglose del Código:

Inicialización del Modelo y Tokenizador:

Cargamos el tokenizador de BERT y el modelo de lenguaje enmascarado
Se utiliza la versión 'bert-base-uncased', que tiene un vocabulario de tokens en minúsculas

Procesamiento de Entrada:

Creamos dos oraciones de ejemplo con tokens [MASK]
El tokenizador convierte el texto en representaciones numéricas que BERT puede procesar

Análisis de Contexto Bidireccional:

BERT analiza el contexto tanto a la izquierda como a la derecha del token enmascarado
En el primer ejemplo, "river" influye en la predicción
En el segundo ejemplo, "deposit money" proporciona un contexto diferente

Generación de Predicciones:

El modelo genera distribuciones de probabilidad para todos los tokens posibles
Seleccionamos el token con la probabilidad más alta como predicción

Salida Esperada:

# Output might look like:
Original text: The [MASK] bank is near the river.
Predicted word: river

Original text: I need to deposit money at the [MASK] bank.
Predicted word: local

Este ejemplo demuestra cómo BERT utiliza el contexto bidireccional para hacer diferentes predicciones para la misma palabra enmascarada basándose en el contexto circundante. El modelo considera tanto las palabras anteriores como las posteriores para comprender el significado apropiado en cada situación.

Paradigma de Pre-entrenamiento y Ajuste Fino

BERT emplea un sofisticado enfoque de aprendizaje en dos fases que revoluciona la forma en que los modelos de lenguaje son entrenados y desplegados. La primera fase, el pre-entrenamiento, implica exponer el modelo a grandes cantidades de datos de texto sin etiquetar de diversas fuentes como Wikipedia, libros y sitios web. Durante esta fase, BERT aprende patrones fundamentales del lenguaje, reglas gramaticales y relaciones semánticas sin tener en mente una tarea específica. Esta comprensión general del lenguaje incluye:

Vocabulario y patrones de uso de palabras
Estructuras y relaciones gramaticales
Significados contextuales de las palabras
Frases y expresiones comunes
Conocimiento básico del mundo incorporado en el lenguaje

La segunda fase, el ajuste fino, es donde BERT adapta su amplia comprensión del lenguaje a tareas específicas. Durante esta fase, el modelo se entrena con un conjunto de datos mucho más pequeño y específico para la tarea. Este proceso implica ajustar los parámetros del modelo para optimizar el rendimiento para la aplicación particular mientras mantiene su conocimiento fundamental del lenguaje. El ajuste fino puede realizarse para varias tareas como:

Análisis de sentimientos
Respuesta a preguntas
Clasificación de texto
Reconocimiento de entidades nombradas
Resumen de documentos

Por ejemplo, BERT puede ser pre-entrenado con miles de millones de palabras de fuentes de texto generales, aprendiendo los patrones amplios del lenguaje. Luego, para una aplicación específica como el análisis de sentimientos, puede ser ajustado finamente usando solo unos pocos miles de reseñas de películas etiquetadas. Este enfoque de dos pasos es altamente eficiente porque:

El proceso costoso y prolongado de pre-entrenamiento solo necesita realizarse una vez
El ajuste fino requiere relativamente pocos datos específicos de la tarea
El proceso puede completarse rápidamente con recursos computacionales mínimos
El modelo resultante mantiene un alto rendimiento al combinar la comprensión amplia del lenguaje con la optimización específica de la tarea

Ejemplo de Código: Pre-entrenamiento y Ajuste Fino de BERT

# 1. Pre-training setup
from transformers import BertConfig, BertForMaskedLM, BertTokenizer
import torch
from torch.utils.data import Dataset, DataLoader

# Custom dataset for pre-training
class PretrainingDataset(Dataset):
    def __init__(self, texts, tokenizer, max_length=512):
        self.encodings = tokenizer(texts, truncation=True, padding='max_length',
                                 max_length=max_length, return_tensors='pt')
        
    def __getitem__(self, idx):
        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
        return item
    
    def __len__(self):
        return len(self.encodings.input_ids)

# Initialize model and tokenizer
config = BertConfig(vocab_size=30522, hidden_size=768)
model = BertForMaskedLM(config)
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# Example pre-training data
pretrain_texts = [
    "The quick brown fox jumps over the lazy dog.",
    "Machine learning is transforming the world of technology."
]

# Create pre-training dataset
pretrain_dataset = PretrainingDataset(pretrain_texts, tokenizer)
pretrain_loader = DataLoader(pretrain_dataset, batch_size=2, shuffle=True)

# Pre-training loop
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)

for epoch in range(3):
    for batch in pretrain_loader:
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

# 2. Fine-tuning for sentiment analysis
from transformers import BertForSequenceClassification

# Convert pre-trained model for classification
model = BertForSequenceClassification.from_pretrained('bert-base-uncased',
                                                     num_labels=2)

# Example fine-tuning data
texts = ["This movie is fantastic!", "The food was terrible."]
labels = torch.tensor([1, 0])  # 1 for positive, 0 for negative

# Prepare fine-tuning data
encodings = tokenizer(texts, truncation=True, padding=True, return_tensors='pt')
dataset = [(encodings, labels)]

# Fine-tuning loop
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)

for epoch in range(3):
    for batch_encodings, batch_labels in dataset:
        outputs = model(**batch_encodings, labels=batch_labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

# 3. Using the fine-tuned model
def predict_sentiment(text):
    inputs = tokenizer(text, return_tensors='pt', truncation=True, padding=True)
    outputs = model(**inputs)
    prediction = torch.argmax(outputs.logits, dim=1)
    return "Positive" if prediction == 1 else "Negative"

# Test the model
test_text = "This is a wonderful example!"
print(f"Sentiment: {predict_sentiment(test_text)}")

Desglose del Código:

Configuración del Pre-entrenamiento (Parte 1):
- Define una clase Dataset personalizada para el manejo de datos de pre-entrenamiento
- Inicializa el modelo BERT con configuración básica
- Crea cargadores de datos para un procesamiento eficiente por lotes
Proceso de Pre-entrenamiento:
- Implementa el bucle de entrenamiento del modelado de lenguaje enmascarado
- Utiliza el optimizador AdamW con tasa de aprendizaje apropiada
- Procesa lotes y actualiza parámetros del modelo
Configuración del Ajuste Fino (Parte 2):
- Convierte el modelo pre-entrenado para clasificación de secuencias
- Prepara el conjunto de datos para análisis de sentimientos
- Implementa el bucle de entrenamiento de ajuste fino
Aplicación del Modelo (Parte 3):
- Crea una función práctica de predicción de sentimientos
- Demuestra cómo usar el modelo ajustado
- Incluye ejemplo de aplicación en el mundo real

Notas Clave de Implementación:

La fase de pre-entrenamiento utiliza modelado de lenguaje enmascarado para aprender patrones generales del lenguaje
El ajuste fino adapta el modelo pre-entrenado para análisis de sentimientos con un entrenamiento adicional mínimo
El ejemplo utiliza un conjunto de datos pequeño para demostración; las aplicaciones reales usarían conjuntos de datos mucho más grandes
Las tasas de aprendizaje se eligen cuidadosamente: más bajas para el ajuste fino (2e-5) que para el pre-entrenamiento (1e-4)

Tokenización con WordPiece

La tokenización WordPiece es el método sofisticado de BERT para dividir palabras en unidades más pequeñas y significativas llamadas subpalabras. En lugar de tratar cada palabra como una unidad indivisible, emplea un enfoque basado en datos para dividir las palabras en subcomponentes comunes. Este proceso funciona identificando primero las secuencias de caracteres más frecuentes en el corpus de entrenamiento, y luego utilizándolas para representar eficientemente tanto palabras comunes como raras.

Por ejemplo, la palabra "incómodo" se dividiría en tres subpalabras: "in" (un prefijo común que significa "no"), "cómodo" (la palabra raíz), y "o" (un sufijo común). De manera similar, términos técnicos como "hiperparámetro" podrían dividirse en "hiper" y "parámetro", mientras que una palabra rara como "inmunoelectroforesis" se descompondría en varias piezas familiares.

Esta estrategia inteligente de tokenización ofrece varias ventajas clave:

Manejo de vocabulario fuera de registro: BERT puede procesar palabras que no ha encontrado durante el entrenamiento dividiéndolas en subpalabras conocidas
Eficiencia de vocabulario: El modelo puede mantener un vocabulario más pequeño mientras cubre una amplia gama de palabras posibles
Conciencia morfológica: El sistema captura naturalmente prefijos, sufijos y palabras raíz comunes
Capacidades multilingües: Se pueden reconocer partes similares de palabras entre idiomas relacionados
Procesamiento de palabras compuestas: Las palabras complejas y la terminología técnica pueden desglosarse y comprenderse efectivamente

Esto hace que BERT sea particularmente experto en el manejo de vocabulario técnico especializado, términos científicos, palabras compuestas y varias formas morfológicas, permitiéndole procesar y comprender una gama mucho más amplia de texto de manera efectiva a través de diferentes dominios e idiomas.

Ejemplo de Código: Tokenización WordPiece

from transformers import BertTokenizer
import pandas as pd

# Initialize the BERT tokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# Example texts with various word types
texts = [
    "immunoelectrophoresis",  # Complex scientific term
    "hyperparameter",         # Technical compound word
    "uncomfortable",          # Word with prefix and suffix
    "pretrained",            # Technical term with prefix
    "3.14159",              # Number
    "AI-powered"            # Hyphenated term
]

# Function to show detailed tokenization
def analyze_tokenization(text):
    # Get tokens and their IDs
    tokens = tokenizer.tokenize(text)
    token_ids = tokenizer.encode(text, add_special_tokens=False)
    
    # Create a detailed breakdown
    return {
        'Original': text,
        'Tokens': tokens,
        'Token IDs': token_ids,
        'Reconstructed': tokenizer.decode(token_ids)
    }

# Analyze each example
results = [analyze_tokenization(text) for text in texts]
df = pd.DataFrame(results)
print(df.to_string())

Desglose del Código:

Inicialización:
- Importamos el tokenizador de BERT desde la biblioteca transformers
- Se utiliza el modelo 'bert-base-uncased', que incluye el vocabulario WordPiece
Selección de Ejemplos:
- Se eligen varios tipos de palabras para demostrar el comportamiento de la tokenización
- Incluye términos científicos, palabras compuestas y caracteres especiales
Función de Análisis:
- El método tokenize() divide las palabras en subpalabras
- encode() convierte los tokens en sus IDs numéricos
- decode() reconstruye el texto original a partir de los IDs

Análisis del Resultado:

# Expected output might look like:
Original: "immunoelectrophoresis"
Tokens: ['imm', '##uno', '##elect', '##ro', '##pho', '##resis']
Token IDs: [2466, 17752, 22047, 2159, 21143, 23875]

Original: "uncomfortable"
Tokens: ['un', '##comfort', '##able']
Token IDs: [2297, 4873, 2137]

Observaciones Clave:

El prefijo '##' indica la continuación de una palabra
Los prefijos comunes (como 'un-') se separan como tokens individuales
Los términos científicos se dividen en subcomponentes significativos
Los números y caracteres especiales reciben un tratamiento especial

Este ejemplo demuestra cómo WordPiece maneja eficazmente varios tipos de palabras mientras mantiene el significado semántico a través de la tokenización inteligente de subpalabras.

5.1.3 Cómo Funciona BERT

Modelado de Lenguaje Enmascarado (MLM):

Durante el pre-entrenamiento, BERT utiliza una técnica sofisticada llamada Modelado de Lenguaje Enmascarado. En este proceso, el 15% de los tokens en cada oración de entrada se enmascaran (ocultan) aleatoriamente del modelo. El modelo entonces aprende a predecir estos tokens enmascarados analizando el contexto circundante en ambos lados de la máscara. Esta comprensión bidireccional del contexto es lo que hace que BERT sea particularmente potente.

El proceso de enmascaramiento sigue reglas específicas:

El 80% de los tokens seleccionados se reemplazan con [MASK]
El 10% se reemplazan con palabras aleatorias
El 10% se dejan sin cambios

Esta variedad en el enmascaramiento ayuda a evitar que el modelo dependa demasiado de patrones específicos y asegura un aprendizaje más robusto.

Ejemplo:

Original: "El gato se sentó en la alfombra."
Enmascarado: "El gato se sentó en [MASK] alfombra."
Tarea: El modelo debe predecir "la" usando el contexto de ambas direcciones
Aprendizaje: El modelo aprende relaciones entre palabras y estructuras gramaticales

Ejemplo de Código: Modelado de Lenguaje Enmascarado

import torch
from transformers import BertTokenizer, BertForMaskedLM
import random

# Initialize tokenizer and model
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForMaskedLM.from_pretrained('bert-base-uncased')

def mask_text(text, mask_probability=0.15):
    # Tokenize the input text
    tokens = tokenizer.tokenize(text)
    
    # Decide which tokens to mask
    mask_indices = []
    for i in range(len(tokens)):
        if random.random() < mask_probability:
            mask_indices.append(i)
    
    # Apply masking strategy
    masked_tokens = tokens.copy()
    for idx in mask_indices:
        rand = random.random()
        if rand < 0.8:  # 80% chance to mask
            masked_tokens[idx] = '[MASK]'
        elif rand < 0.9:  # 10% chance to replace with random token
            random_token = tokenizer.convert_ids_to_tokens(
                [random.randint(0, tokenizer.vocab_size)])[0]
            masked_tokens[idx] = random_token
        # 10% chance to keep original token
    
    return tokens, masked_tokens, mask_indices

def predict_masked_tokens(original_tokens, masked_tokens):
    # Convert tokens to input IDs
    inputs = tokenizer.convert_tokens_to_string(masked_tokens)
    inputs = tokenizer(inputs, return_tensors='pt')
    
    # Get model predictions
    with torch.no_grad():
        outputs = model(**inputs)
        predictions = outputs.logits.squeeze()
    
    # Get predictions for masked tokens
    results = []
    for idx in range(len(masked_tokens)):
        if masked_tokens[idx] == '[MASK]':
            predicted_token_id = predictions[idx].argmax().item()
            predicted_token = tokenizer.convert_ids_to_tokens([predicted_token_id])[0]
            results.append({
                'position': idx,
                'original': original_tokens[idx],
                'predicted': predicted_token
            })
    
    return results

# Example usage
text = "The cat sat on the mat while drinking milk."
original_tokens, masked_tokens, mask_indices = mask_text(text)

print("Original:", ' '.join(original_tokens))
print("Masked:", ' '.join(masked_tokens))

predictions = predict_masked_tokens(original_tokens, masked_tokens)
for pred in predictions:
    print(f"Position {pred['position']}: Original '{pred['original']}' → Predicted '{pred['predicted']}'")

Desglose del Código:

Inicialización:
- Carga el modelo BERT preentrenado y el tokenizador específicamente configurado para el modelado de lenguaje enmascarado
- Utiliza 'bert-base-uncased' que tiene un vocabulario de 30,522 tokens
Función de Enmascaramiento (mask_text):
- Implementa la probabilidad de enmascaramiento del 15% de BERT
- Aplica la estrategia de enmascaramiento 80-10-10 (máscara/aleatorio/sin cambios)
- Devuelve tanto las versiones originales como las enmascaradas para comparación
Función de Predicción (predict_masked_tokens):
- Convierte el texto enmascarado en entradas para el modelo
- Utiliza BERT para predecir los tokens más probables para las posiciones enmascaradas
- Devuelve resultados detallados de predicción para análisis

Ejemplo de Salida:

# Sample output might look like:
Original: the cat sat on the mat while drinking milk
Masked: the cat [MASK] on the mat [MASK] drinking milk
Position 2: Original 'sat' → Predicted 'sat'
Position 6: Original 'while' → Predicted 'while'

Notas Clave de Implementación:

El modelo utiliza información contextual de ambas direcciones para hacer predicciones
Las predicciones se basan en distribuciones de probabilidad sobre todo el vocabulario
El proceso de enmascaramiento es aleatorizado para crear ejemplos de entrenamiento diversos
La implementación maneja eficazmente tanto tokens individuales como secuencias más largas

Predicción de la Siguiente Oración (NSP):

BERT también aprende relaciones entre oraciones a través de la Predicción de la Siguiente Oración (NSP), una tarea crucial de pre-entrenamiento. En NSP, al modelo se le proporcionan pares de oraciones y debe determinar si la segunda oración sigue naturalmente a la primera en el documento original. Esto ayuda a BERT a comprender la coherencia a nivel de documento y las relaciones discursivas.

Durante el entrenamiento, el 50% de los pares de oraciones son oraciones consecutivas reales de documentos (etiquetadas como "IsNext"), mientras que el otro 50% son pares de oraciones aleatorias (etiquetadas como "NotNext"). Este enfoque equilibrado ayuda al modelo a aprender a distinguir entre secuencias de oraciones coherentes y no relacionadas.

Ejemplo:

Oración A: "El gato se sentó en la alfombra."
Oración B: "Era un día soleado."
Resultado: "No Siguiente" (Las oraciones no están relacionadas)

En este ejemplo, aunque ambas oraciones son gramaticalmente correctas, carecen de continuidad temática o conexión lógica. Una oración de seguimiento más natural podría ser "Estaba tomando una siesta bajo el sol de la tarde." El modelo aprende a reconocer estas relaciones contextuales a través de la exposición a millones de pares de oraciones durante el pre-entrenamiento.

Ejemplo de Código: Predicción de la Siguiente Oración

from transformers import BertTokenizer, BertForNextSentencePrediction
import torch

def check_sentence_pair(sentence_a, sentence_b):
    # Initialize tokenizer and model
    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
    model = BertForNextSentencePrediction.from_pretrained('bert-base-uncased')
    
    # Encode the sentence pair
    encoding = tokenizer(
        sentence_a,
        sentence_b,
        return_tensors='pt',
        max_length=512,
        truncation=True,
        padding='max_length'
    )
    
    # Get model prediction
    with torch.no_grad():
        outputs = model(**encoding)
        logits = outputs.logits
        prob = torch.softmax(logits, dim=1)
        
        # prob[0][0] = probability of "NotNext"
        # prob[0][1] = probability of "IsNext"
        is_next_prob = prob[0][1].item()
    
    return is_next_prob

# Example sentence pairs
sentence_pairs = [
    # Related pair (should be "IsNext")
    ("The cat sat on the mat.", "It was feeling sleepy and comfortable."),
    
    # Unrelated pair (should be "NotNext")
    ("The weather is beautiful today.", "Quantum physics explains particle behavior."),
    
    # Related pair with context
    ("Scientists discovered a new species.", "The findings were published in Nature journal."),
]

# Test each pair
for sent_a, sent_b in sentence_pairs:
    prob = check_sentence_pair(sent_a, sent_b)
    print(f"\nSentence A: {sent_a}")
    print(f"Sentence B: {sent_b}")
    print(f"Probability of B following A: {prob:.2%}")
    print(f"Prediction: {'IsNext' if prob > 0.5 else 'NotNext'}")

Desglose del Código:

Configuración del Modelo:
- Inicializa el tokenizador de BERT y el modelo NSP especializado
- Utiliza 'bert-base-uncased' que está preentrenado en tareas NSP
Procesamiento de Entrada:
- Tokeniza ambas oraciones con tokens especiales ([CLS], [SEP])
- Gestiona el relleno y truncamiento para mantener un tamaño de entrada consistente
- Devuelve tensores adecuados para el procesamiento de BERT
Predicción:
- El modelo genera logits que representan probabilidades para IsNext/NotNext
- Softmax convierte los logits en probabilidades entre 0 y 1
- Devuelve la probabilidad de que las oraciones sean consecutivas

Ejemplo de Salida:

# Expected output:
Sentence A: The cat sat on the mat.
Sentence B: It was feeling sleepy and comfortable.
Probability of B following A: 87.65%
Prediction: IsNext

Sentence A: The weather is beautiful today.
Sentence B: Quantum physics explains particle behavior.
Probability of B following A: 12.34%
Prediction: NotNext

Notas Clave de Implementación:

El modelo considera tanto las relaciones semánticas como contextuales entre oraciones
Las probabilidades más cercanas a 1 indican una mayor probabilidad de que las oraciones sean consecutivas
Se utiliza un umbral de 0.5 para tomar decisiones binarias de EsSiguiente/NoEsSiguiente
El modelo puede manejar varios tipos de relaciones, desde continuaciones directas hasta coherencia temática

5.1.4 Variantes de BERT

RoBERTa (Enfoque de Pre-entrenamiento de BERT Robustamente Optimizado)

RoBERTa (Enfoque BERT Robusto), desarrollado por Facebook AI Research, representa un avance significativo en la arquitectura de BERT al implementar varias optimizaciones cruciales en el proceso de pre-entrenamiento:

Elimina la tarea de Predicción de la Siguiente Oración (NSP) para centrarse únicamente en el Modelado de Lenguaje Enmascarado (MLM):
- La investigación mostró que los beneficios de NSP eran mínimos en comparación con MLM
- Centrarse en MLM permite un entrenamiento más eficiente y una mejor comprensión del lenguaje
Entrena con más datos y tamaños de lote más grandes:
- Utiliza 160GB de texto en comparación con los 16GB de BERT
- Implementa tamaños de lote más grandes (8K tokens) para un entrenamiento más estable
- Entrena durante períodos más largos para lograr una mejor convergencia del modelo
Utiliza enmascaramiento dinámico para proporcionar ejemplos de entrenamiento variados:
- BERT utilizaba enmascaramiento estático aplicado una vez durante el preprocesamiento de datos
- RoBERTa genera nuevos patrones de enmascaramiento cada vez que se alimenta una secuencia al modelo
- Esto evita que el modelo memorice patrones específicos y mejora la generalización

Beneficios Principales:

Mejor rendimiento en puntos de referencia de PLN:
- Supera consistentemente a BERT en los puntos de referencia GLUE, SQuAD y RACE
- Muestra mejoras significativas en tareas de razonamiento complejo
Mayor robustez y precisión en tareas derivadas:
- Proceso de ajuste fino más estable
- Mejores capacidades de transferencia de aprendizaje para tareas de dominio específico
- Mejor rendimiento en escenarios de recursos limitados

Ejemplo de Código: Uso de RoBERTa para Clasificación de Texto

from transformers import RobertaTokenizer, RobertaForSequenceClassification
import torch
from torch.utils.data import Dataset, DataLoader

# Initialize tokenizer and model
tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
model = RobertaForSequenceClassification.from_pretrained('roberta-base', num_labels=2)

class TextDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, 
                                 max_length=max_length, return_tensors='pt')
        self.labels = torch.tensor(labels)

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = self.labels[idx]
        return item

    def __len__(self):
        return len(self.labels)

# Example training data
texts = [
    "This movie was absolutely fantastic!",
    "The plot was confusing and boring.",
    "A masterpiece of modern cinema.",
    "Waste of time and money."
]
labels = [1, 0, 1, 0]  # 1 for positive, 0 for negative

# Create dataset and dataloader
dataset = TextDataset(texts, labels, tokenizer)
loader = DataLoader(dataset, batch_size=2, shuffle=True)

# Training setup
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-5)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)

# Training loop
def train(epochs=3):
    model.train()
    for epoch in range(epochs):
        total_loss = 0
        for batch in loader:
            optimizer.zero_grad()
            
            # Move batch to device
            input_ids = batch['input_ids'].to(device)
            attention_mask = batch['attention_mask'].to(device)
            labels = batch['labels'].to(device)
            
            # Forward pass
            outputs = model(input_ids, attention_mask=attention_mask, 
                          labels=labels)
            loss = outputs.loss
            
            # Backward pass
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
            
        print(f"Epoch {epoch+1}, Average loss: {total_loss/len(loader)}")

# Prediction function
def predict(text):
    model.eval()
    with torch.no_grad():
        inputs = tokenizer(text, return_tensors='pt', 
                         truncation=True, padding=True).to(device)
        outputs = model(**inputs)
        predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
        return predictions.cpu().numpy()

# Train the model
train()

# Example prediction
test_text = "This is an amazing example of natural language processing!"
prediction = predict(test_text)
print(f"Prediction probabilities: Negative: {prediction[0][0]:.3f}, Positive: {prediction[0][1]:.3f}")

Desglose del Código:

Inicialización del Modelo y Tokenizador:
- Utiliza el tokenizador y modelo pre-entrenado de RoBERTa para clasificación de secuencias
- Configura el modelo para clasificación binaria (positivo/negativo)
Implementación del Dataset Personalizado:
- Crea una clase Dataset de PyTorch para el manejo eficiente de datos
- Gestiona la tokenización y conversión a tensores
- Implementa los métodos requeridos de Dataset de PyTorch (__getitem__, __len__)
Pipeline de Entrenamiento:
- Utiliza el optimizador AdamW con una tasa de aprendizaje pequeña para el ajuste fino
- Implementa entrenamiento independiente del dispositivo (CPU/GPU)
- Incluye un bucle completo de entrenamiento con seguimiento de pérdida
Función de Predicción:
- Implementa pipeline de inferencia para entradas de texto individuales
- Devuelve distribuciones de probabilidad para clasificación
- Maneja todo el preprocesamiento necesario automáticamente

Notas Clave de Implementación:

RoBERTa utiliza un enfoque de tokenización diferente al de BERT, optimizado para mejor rendimiento
El modelo maneja automáticamente el relleno y truncamiento para longitudes variables de texto
La implementación incluye gestión adecuada de memoria con puesta a cero de gradientes y procesamiento por lotes
El código demuestra tanto las fases de entrenamiento como de inferencia del modelo

DistilBERT:

DistilBERT representa un avance significativo en hacer BERT más práctico y accesible. Es una versión comprimida de BERT que mantiene la mayoría de sus capacidades mientras es significativamente más eficiente. A través de un proceso llamado destilación del conocimiento, DistilBERT aprende a replicar el comportamiento de BERT entrenando un modelo estudiante más pequeño para que coincida con las salidas del modelo maestro más grande (BERT). Este proceso implica no solo copiar las salidas finales, sino también aprender las representaciones internas y patrones de atención que hacen exitoso a BERT.

El proceso de destilación equilibra cuidadosamente tres objetivos clave de entrenamiento:

Hacer coincidir las probabilidades objetivo suaves producidas por el modelo maestro
Mantener el mismo objetivo de modelado de lenguaje enmascarado que BERT
Preservar la similitud del coseno entre los estados ocultos del maestro y el estudiante
A través de estas optimizaciones, DistilBERT logra mejoras notables en eficiencia:
- 40% de reducción en el tamaño del modelo (de 110M a 66M parámetros)
- 60% más velocidad de procesamiento durante la inferencia
- Mantiene el 97% de las capacidades de comprensión del lenguaje de BERT

Beneficios Principales:

Ideal para implementación en entornos con recursos limitados:
- Adecuado para dispositivos móviles y computación en el borde
- La huella de memoria reducida permite más opciones de implementación
- Menores requisitos computacionales significan menor consumo de energía
Inferencia más rápida con pérdida mínima de rendimiento:
- Permite aplicaciones en tiempo real y mayor rendimiento
- Mantiene alta precisión en la mayoría de tareas de PLN
- Más rentable para implementaciones a gran escala

Ejemplo de Código: Uso de DistilBERT para Clasificación de Texto

from transformers import DistilBertTokenizer, DistilBertForSequenceClassification
import torch
from torch.utils.data import Dataset, DataLoader

# Initialize tokenizer and model
tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')
model = DistilBertForSequenceClassification.from_pretrained('distilbert-base-uncased', num_labels=2)

class TextClassificationDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, 
                                 max_length=max_length, return_tensors='pt')
        self.labels = torch.tensor(labels)

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = self.labels[idx]
        return item

    def __len__(self):
        return len(self.labels)

# Example data
texts = [
    "This product exceeded my expectations!",
    "Very disappointed with the quality.",
    "Great value for money, highly recommend.",
    "Customer service was terrible."
]
labels = [1, 0, 1, 0]  # 1: Positive, 0: Negative

# Create dataset and dataloader
dataset = TextClassificationDataset(texts, labels, tokenizer)
loader = DataLoader(dataset, batch_size=2, shuffle=True)

# Training configuration
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5)
num_epochs = 3

# Training loop
def train_model():
    model.train()
    for epoch in range(num_epochs):
        total_loss = 0
        for batch in loader:
            optimizer.zero_grad()
            
            # Move batch to device
            input_ids = batch['input_ids'].to(device)
            attention_mask = batch['attention_mask'].to(device)
            labels = batch['labels'].to(device)
            
            # Forward pass
            outputs = model(input_ids, attention_mask=attention_mask, 
                          labels=labels)
            loss = outputs.loss
            
            # Backward pass and optimization
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
        
        avg_loss = total_loss / len(loader)
        print(f"Epoch {epoch + 1}/{num_epochs}, Average Loss: {avg_loss:.4f}")

# Inference function
def predict_sentiment(text):
    model.eval()
    with torch.no_grad():
        inputs = tokenizer(text, return_tensors='pt', 
                         truncation=True, padding=True).to(device)
        outputs = model(**inputs)
        probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
        return probs.cpu().numpy()[0]

# Train the model
train_model()

# Example prediction
test_text = "The customer support team was very helpful!"
prediction = predict_sentiment(test_text)
print(f"\nTest text: {test_text}")
print(f"Sentiment prediction: Negative: {prediction[0]:.3f}, Positive: {prediction[1]:.3f}")

Desglose del Código:

Configuración del Modelo y Tokenizador:
- Inicializa el tokenizador y modelo de clasificación de DistilBERT
- Utiliza el modelo pre-entrenado 'distilbert-base-uncased'
- Configura para clasificación binaria (sentimiento positivo/negativo)
Implementación del Dataset Personalizado:
- Crea una clase Dataset de PyTorch para el manejo eficiente de datos
- Gestiona la tokenización y conversión a tensores
- Implementa los métodos requeridos de Dataset para compatibilidad con PyTorch
Pipeline de Entrenamiento:
- Utiliza el optimizador AdamW con una tasa de aprendizaje de 5e-5
- Implementa entrenamiento independiente del dispositivo (CPU/GPU)
- Incluye seguimiento de pérdida y reporte de progreso por época
Implementación de Inferencia:
- Proporciona una función dedicada de predicción para entradas de texto individuales
- Devuelve distribuciones de probabilidad para clasificación binaria
- Maneja automáticamente todos los pasos necesarios de preprocesamiento

Notas Clave de Implementación:

El código demuestra la eficiencia de DistilBERT mientras mantiene el rendimiento similar a BERT
La implementación incluye gestión adecuada de memoria y procesamiento por lotes
El modelo maneja automáticamente el preprocesamiento y tokenización del texto
Muestra tanto las fases de entrenamiento como de inferencia con ejemplos prácticos

Ejemplo Práctico: Uso de BERT y sus Variantes

Usemos Hugging Face Transformers para cargar y ajustar BERT, RoBERTa y DistilBERT para una tarea de clasificación de texto.

Ejemplo de Código: Ajuste Fino de BERT para Análisis de Sentimiento

from transformers import BertTokenizer, BertForSequenceClassification, Trainer, TrainingArguments
from torch.utils.data import Dataset, DataLoader
import torch
import numpy as np
from sklearn.metrics import accuracy_score, precision_recall_fscore_support

# Custom Dataset Class
class SentimentDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, 
                                 max_length=max_length, return_tensors="pt")
        self.labels = torch.tensor(labels)

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = self.labels[idx]
        return item

# Metrics computation function
def compute_metrics(pred):
    labels = pred.label_ids
    preds = pred.predictions.argmax(-1)
    precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='binary')
    acc = accuracy_score(labels, preds)
    return {
        'accuracy': acc,
        'f1': f1,
        'precision': precision,
        'recall': recall
    }

# Load pre-trained BERT and tokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
model = BertForSequenceClassification.from_pretrained(
    "bert-base-uncased",
    num_labels=2,
    output_attentions=True
)

# Example data
texts = [
    "The movie was fantastic!",
    "I did not enjoy the food.",
    "This is the best book I've ever read!",
    "The service was terrible and slow.",
    "Absolutely loved the experience!"
]
labels = [1, 0, 1, 0, 1]  # 1 = Positive, 0 = Negative

# Create datasets
train_dataset = SentimentDataset(texts, labels, tokenizer)

# Define training arguments
training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
    logging_dir='./logs',
    logging_steps=10,
    load_best_model_at_end=True,
    metric_for_best_model='f1',
    save_strategy="epoch"
)

# Initialize trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    compute_metrics=compute_metrics
)

# Train the model
trainer.train()

# Example inference
def predict_sentiment(text):
    # Prepare input
    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
    
    # Get prediction
    with torch.no_grad():
        outputs = model(**inputs)
        probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
        prediction = torch.argmax(probabilities, dim=-1)
    
    return {
        "text": text,
        "sentiment": "Positive" if prediction == 1 else "Negative",
        "confidence": float(probabilities[0][prediction])
    }

# Test predictions
test_texts = [
    "I would highly recommend this product!",
    "This was a complete waste of money."
]

for text in test_texts:
    result = predict_sentiment(text)
    print(f"\nText: {result['text']}")
    print(f"Sentiment: {result['sentiment']}")
    print(f"Confidence: {result['confidence']:.4f}")

Desglose y Explicación del Código:

Implementación del Dataset Personalizado:
- Crea una clase Dataset personalizada de PyTorch (SentimentDataset)
- Maneja la tokenización y conversión de datos de texto a tensores
- Implementa los métodos requeridos de Dataset (__len__, __getitem__)
Configuración y Preparación del Modelo:
- Inicializa el tokenizador y modelo de clasificación BERT
- Configura para clasificación binaria de sentimientos
- Habilita las salidas de atención para análisis potencial
Configuración del Entrenamiento:
- Define argumentos completos de entrenamiento
- Implementa configuraciones de tasa de aprendizaje y tamaño de lote
- Incluye estrategias de registro y guardado del modelo
Métricas y Evaluación:
- Implementa la función compute_metrics para seguimiento del rendimiento
- Calcula precisión, puntuación F1, precisión y exhaustividad
- Permite la evaluación del modelo durante el entrenamiento
Pipeline de Inferencia:
- Crea una función dedicada de predicción
- Maneja entradas de texto individuales con preprocesamiento adecuado
- Devuelve resultados detallados de predicción con puntuaciones de confianza

5.1.5 Casos de Uso Clave de BERT y sus Variantes

Clasificación de Texto:

Como se ha discutido, modelos como BERT y RoBERTa han revolucionado la clasificación de texto al sobresalir en la categorización de textos en grupos predefinidos con notable precisión. Estos modelos sofisticados aprovechan arquitecturas de aprendizaje profundo para analizar el contenido del texto en múltiples niveles - desde palabras individuales hasta frases complejas y relaciones contextuales. Pueden asignar etiquetas apropiadas con alta precisión al comprender tanto el significado explícito como implícito dentro del texto.

Por ejemplo, en el análisis de sentimientos, estos modelos van más allá de la simple clasificación positiva/negativa. Pueden detectar matices emocionales sutiles y señales contextuales en reseñas de productos, publicaciones en redes sociales y comentarios de clientes. Esto incluye la comprensión del sarcasmo, la identificación de sentimientos mixtos y el reconocimiento de subtextos emocionales implícitos que podrían pasar desapercibidos para sistemas de clasificación más simples.

En la detección de spam, estos modelos demuestran su versatilidad al identificar tanto patrones de spam obvios como sofisticados. Pueden reconocer patrones de contenido sospechoso, analizar estructuras lingüísticas y detectar características inusuales de mensajes que podrían indicar comunicaciones no deseadas. Esta capacidad va más allá del simple cotejo de palabras clave para comprender indicadores de spam dependientes del contexto, tácticas de spam en evolución y matices específicos del lenguaje, ayudando a mantener canales de comunicación limpios y seguros en diversas plataformas.

Respuesta a Preguntas:

La comprensión bidireccional de BERT representa un avance significativo en el procesamiento del lenguaje natural, ya que permite que el modelo comprenda el contexto tanto de las palabras precedentes como de las siguientes en un texto simultáneamente. A diferencia de los modelos unidireccionales tradicionales que procesan el texto de izquierda a derecha o de derecha a izquierda, la arquitectura transformer de BERT procesa toda la secuencia a la vez, creando representaciones contextuales ricas para cada palabra.

Esta capacidad sofisticada hace que BERT sea particularmente efectivo para extraer respuestas precisas de pasajes. Cuando se le presenta una pregunta, el modelo emplea múltiples capas de atención para analizar las relaciones entre palabras tanto en la pregunta como en el pasaje. Puede identificar pistas contextuales sutiles, resolver referencias ambiguas y comprender patrones lingüísticos complejos que podrían pasar desapercibidos para modelos más simples.

La destreza del modelo en respuesta a preguntas proviene de su capacidad para:

Procesar relaciones semánticas entre palabras y frases a través de largas distancias en el texto
Comprender diversos tipos de preguntas, desde consultas factuales hasta preguntas de razonamiento más abstracto
Considerar múltiples niveles de contexto simultáneamente, desde la comprensión a nivel de palabra hasta nivel de oración
Generar respuestas contextualmente apropiadas sintetizando información de diferentes partes del pasaje

Esta capacidad avanzada de comprensión ha transformado numerosas aplicaciones del mundo real. En chatbots, permite conversaciones más naturales y conscientes del contexto. Los asistentes virtuales ahora pueden proporcionar respuestas más precisas y relevantes al comprender mejor las consultas de los usuarios en contexto. Los sistemas de atención al cliente se benefician de una generación de respuestas automatizada mejorada, lo que lleva a mejores tasas de resolución en el primer contacto y menor necesidad de intervención humana. Estas aplicaciones demuestran cómo la comprensión bidireccional de BERT ha revolucionado las implementaciones prácticas de PLN.

Ejemplo de Código: Respuesta a Preguntas con BERT

from transformers import AutoTokenizer, AutoModelForQuestionAnswering
import torch

def setup_qa_model():
    # Initialize tokenizer and model
    tokenizer = AutoTokenizer.from_pretrained("bert-large-uncased-whole-word-masking-finetuned-squad")
    model = AutoModelForQuestionAnswering.from_pretrained("bert-large-uncased-whole-word-masking-finetuned-squad")
    return tokenizer, model

def answer_question(question, context, tokenizer, model):
    # Tokenize input text
    inputs = tokenizer(
        question,
        context,
        add_special_tokens=True,
        return_tensors="pt",
        max_length=512,
        truncation=True,
        padding='max_length'
    )
    
    # Get model predictions
    with torch.no_grad():
        outputs = model(**inputs)
        answer_start = outputs.start_logits.argmax()
        answer_end = outputs.end_logits.argmax()
    
    # Convert token positions to text
    tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
    answer = tokenizer.convert_tokens_to_string(tokens[answer_start:answer_end + 1])
    
    # Calculate confidence scores
    start_scores = torch.softmax(outputs.start_logits, dim=1)[0]
    end_scores = torch.softmax(outputs.end_logits, dim=1)[0]
    confidence = float((start_scores[answer_start] * end_scores[answer_end]).item())
    
    return {
        "answer": answer,
        "confidence": confidence,
        "start": answer_start,
        "end": answer_end
    }

# Example usage
tokenizer, model = setup_qa_model()

context = """
The Transformer architecture was introduced in the paper 'Attention Is All You Need' 
by Vaswani et al. in 2017. BERT, which stands for Bidirectional Encoder Representations 
from Transformers, was developed by researchers at Google AI Language in 2018. It 
revolutionized NLP by introducing bidirectional training and achieving state-of-the-art 
results on various language tasks.
"""

questions = [
    "When was the Transformer architecture introduced?",
    "Who developed BERT?",
    "What does BERT stand for?"
]

for question in questions:
    result = answer_question(question, context, tokenizer, model)
    print(f"\nQuestion: {question}")
    print(f"Answer: {result['answer']}")
    print(f"Confidence: {result['confidence']:.4f}")

Desglose del código:

Configuración e Inicialización del Modelo:
- Utiliza un modelo BERT pre-entrenado específicamente ajustado para responder preguntas en el conjunto de datos SQuAD
- Inicializa tanto el tokenizador como el modelo desde la biblioteca transformers de Hugging Face
Implementación de la Función de Respuesta a Preguntas:
- Maneja el preprocesamiento de entrada con tokenización adecuada
- Gestiona la longitud máxima de secuencia y el truncamiento
- Implementa procesamiento por lotes eficiente con PyTorch
Proceso de Extracción de Respuestas:
- Identifica las posiciones de inicio y fin de la respuesta en el texto
- Convierte las posiciones de tokens a texto legible
- Calcula puntuaciones de confianza para las predicciones
Procesamiento de Resultados:
- Devuelve una salida estructurada con la respuesta, puntuación de confianza e información de posición
- Maneja casos extremos y posibles errores en la extracción de respuestas
- Proporciona métricas de confianza significativas para la fiabilidad de las respuestas

Esta implementación demuestra la capacidad de BERT para comprender el contexto y extraer información relevante de pasajes de texto. El modelo procesa tanto la pregunta como el contexto simultáneamente, aprovechando su mecanismo de atención bidireccional para identificar el segmento de respuesta más apropiado.

Reconocimiento de Entidades Nombradas (NER)

Las capacidades de Reconocimiento de Entidades Nombradas (NER) permiten que estos modelos realicen una identificación y clasificación sofisticada de entidades dentro del texto con una precisión excepcional. Los modelos emplean una comprensión contextual avanzada para detectar y categorizar varias entidades:

Nombres de personas, incluyendo variaciones y apodos
Expresiones temporales como fechas, horas y duraciones
Ubicaciones geográficas a diferentes escalas (ciudades, países, puntos de referencia)
Nombres de organizaciones, incluyendo empresas, instituciones y organismos gubernamentales
Nombres de productos y marcas en diferentes industrias
Valores monetarios en varias monedas y formatos
Entidades personalizadas específicas para dominios o industrias particulares

Esta sofisticada funcionalidad de reconocimiento de entidades sirve como piedra angular para numerosas aplicaciones prácticas:

Revisión de Documentos Legales: Identificación automática de partes, fechas, montos monetarios y entidades legales
Análisis de Registros Médicos: Extracción de información del paciente, condiciones médicas, medicamentos y fechas de tratamiento
Inteligencia Empresarial: Seguimiento de menciones de empresas, referencias de productos y tendencias del mercado
Investigación y Academia: Identificación de citas, nombres de autores y afiliaciones institucionales
Análisis Financiero: Detección de nombres de empresas, valores monetarios y detalles de transacciones
Noticias y Medios: Categorización de personas, organizaciones y ubicaciones en artículos de noticias

La capacidad de la tecnología para comprender el contexto y las relaciones entre entidades la hace particularmente valiosa para sistemas automatizados de procesamiento de documentos, donde la precisión y la fiabilidad son primordiales.

Ejemplo de Código: Reconocimiento de Entidades Nombradas con BERT

from transformers import AutoTokenizer, AutoModelForTokenClassification
import torch
from torch.nn import functional as F

def setup_ner_model():
    # Initialize tokenizer and model for NER
    tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")
    model = AutoModelForTokenClassification.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")
    return tokenizer, model

def perform_ner(text, tokenizer, model):
    # Tokenize input text
    inputs = tokenizer(
        text,
        add_special_tokens=True,
        return_tensors="pt",
        truncation=True,
        max_length=512
    )
    
    # Get predictions
    with torch.no_grad():
        outputs = model(**inputs)
        predictions = F.softmax(outputs.logits, dim=-1)
        predictions = torch.argmax(predictions, dim=-1)
    
    # Process tokens and predictions
    tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
    label_list = model.config.id2label
    
    entities = []
    current_entity = None
    
    for idx, (token, pred) in enumerate(zip(tokens, predictions[0])):
        label = label_list[pred.item()]
        
        # Skip special tokens
        if token in [tokenizer.sep_token, tokenizer.cls_token, tokenizer.pad_token]:
            continue
            
        # Handle B- (beginning) and I- (inside) tags
        if label.startswith("B-"):
            if current_entity:
                entities.append(current_entity)
            current_entity = {
                "entity": token.replace("##", ""),
                "type": label[2:],
                "start": idx
            }
        elif label.startswith("I-") and current_entity:
            current_entity["entity"] += token.replace("##", "")
        elif label == "O":  # Outside any entity
            if current_entity:
                entities.append(current_entity)
                current_entity = None
    
    if current_entity:
        entities.append(current_entity)
    
    return entities

# Example usage
def demonstrate_ner():
    tokenizer, model = setup_ner_model()
    
    sample_text = """
    Apple Inc. CEO Tim Cook announced a new partnership with Microsoft 
    Corporation in New York City last Friday. The deal, worth $5 billion, 
    will help both companies expand their presence in the artificial 
    intelligence market.
    """
    
    entities = perform_ner(sample_text, tokenizer, model)
    
    # Print results
    for entity in entities:
        print(f"Entity: {entity['entity']}")
        print(f"Type: {entity['type']}")
        print("---")

Desglose y Explicación del Código:

Inicialización y Configuración del Modelo:
- Utiliza un modelo BERT pre-entrenado específicamente ajustado para tareas de NER
- Aprovecha la biblioteca transformers de Hugging Face para la configuración del modelo y tokenizador
- Configura el modelo para la clasificación de tokens con etiquetas de entidades
Función de Procesamiento NER:
- Implementa tokenización eficiente con manejo adecuado de tokens especiales
- Gestiona limitaciones de longitud de secuencia y truncamiento
- Utiliza el contexto no_grad de PyTorch para inferencia eficiente
Reconocimiento y Procesamiento de Entidades:
- Maneja el esquema de etiquetado BIO (Principio, Dentro, Fuera)
- Procesa tokens parciales y reconstruye entidades completas
- Mantiene con precisión los límites y tipos de entidades
Procesamiento de Salida:
- Crea una salida estructurada con texto de entidad, tipo e información de posición
- Maneja casos extremos y reconstrucción de tokens
- Proporciona resultados limpios y organizados de extracción de entidades

Esta implementación demuestra la capacidad de BERT para identificar y clasificar entidades nombradas en texto con alta precisión. El modelo puede reconocer varios tipos de entidades incluyendo personas, organizaciones, ubicaciones y fechas, haciéndolo valioso para tareas de extracción de información en diferentes dominios.

Tareas con Recursos Limitados:

DistilBERT representa un avance significativo en hacer los modelos transformer más prácticos y accesibles. Aborda específicamente los desafíos computacionales que surgen frecuentemente al implementar estos modelos sofisticados en entornos con recursos limitados. A través de un proceso llamado destilación del conocimiento, donde un modelo más pequeño (estudiante) aprende a imitar el comportamiento de un modelo más grande (maestro), DistilBERT logra mejoras notables en eficiencia mientras mantiene el rendimiento.

Los logros clave de DistilBERT son impresionantes:

Retención de Rendimiento: Preserva aproximadamente el 97% de las capacidades de comprensión del lenguaje de BERT, asegurando resultados de alta calidad
Optimización de Tamaño: El modelo logra una reducción del 40% en tamaño comparado con BERT, requiriendo significativamente menos espacio de almacenamiento
Mejora de Velocidad: La velocidad de procesamiento aumenta en un 60%, permitiendo tiempos de inferencia más rápidos y mejor capacidad de respuesta

Estas mejoras hacen que DistilBERT sea particularmente valioso para varias aplicaciones del mundo real:

Aplicaciones Móviles: Permite características sofisticadas de PLN en smartphones y tablets sin consumo excesivo de batería o requisitos de almacenamiento
Computación de Borde: Permite el procesamiento local en dispositivos IoT y servidores edge, reduciendo la necesidad de conectividad en la nube
Sistemas en Tiempo Real: Admite aplicaciones que requieren respuestas inmediatas, como traducción en vivo o análisis de mensajes instantáneos
Entornos con Recursos Limitados: Hace el PLN avanzado accesible en entornos con poder computacional o memoria limitados

Ejemplo de Código: Tareas con Recursos Limitados usando DistilBERT

from transformers import DistilBertTokenizer, DistilBertForSequenceClassification
import torch
from torch.nn import functional as F

def setup_distilbert():
    # Initialize tokenizer and model
    tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')
    model = DistilBertForSequenceClassification.from_pretrained(
        'distilbert-base-uncased',
        num_labels=2  # Binary classification
    )
    return tokenizer, model

def optimize_model_for_inference(model):
    # Convert to inference mode
    model.eval()
    # Quantize model to reduce memory footprint
    model = torch.quantization.quantize_dynamic(
        model, {torch.nn.Linear}, dtype=torch.qint8
    )
    return model

def process_text(text, tokenizer, model, max_length=128):
    # Tokenize with truncation
    inputs = tokenizer(
        text,
        truncation=True,
        max_length=max_length,
        padding='max_length',
        return_tensors='pt'
    )
    
    # Efficient inference
    with torch.no_grad():
        outputs = model(**inputs)
        predictions = F.softmax(outputs.logits, dim=-1)
    
    return predictions

def batch_process_texts(texts, tokenizer, model, batch_size=16):
    results = []
    
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        batch_predictions = process_text(batch, tokenizer, model)
        results.extend(batch_predictions.tolist())
    
    return results

# Example usage
def demonstrate_resource_constrained_classification():
    tokenizer, model = setup_distilbert()
    model = optimize_model_for_inference(model)
    
    sample_texts = [
        "This product works great and I'm very satisfied!",
        "The quality is terrible, would not recommend.",
        "Decent product for the price point."
    ]
    
    predictions = batch_process_texts(sample_texts, tokenizer, model)
    
    for text, pred in zip(sample_texts, predictions):
        sentiment = "Positive" if pred[1] > 0.5 else "Negative"
        confidence = max(pred)
        print(f"Text: {text}")
        print(f"Sentiment: {sentiment} (Confidence: {confidence:.2f})")
        print("---")

Desglose del Código:

Configuración y Optimización del Modelo:
- Inicializa DistilBERT con una configuración mínima para clasificación de secuencias
- Implementa la cuantización del modelo para reducir el uso de memoria
- Configura el modelo para un modo de inferencia eficiente
Función de Procesamiento de Texto:
- Implementa tokenización eficiente con restricciones de longitud
- Utiliza procesamiento por lotes dinámico para un uso óptimo de recursos
- Gestiona la memoria eficientemente con el contexto no_grad
Técnicas de Optimización de Recursos:
- Emplea cuantización del modelo para reducir la huella de memoria
- Implementa procesamiento por lotes para maximizar el rendimiento
- Utiliza estrategias de truncamiento y relleno para gestionar longitudes de secuencia
Consideraciones de Rendimiento:
- Equilibra el tamaño del lote con las restricciones de memoria
- Implementa agregación eficiente de predicciones
- Proporciona puntuaciones de confianza para la fiabilidad de las predicciones

Esta implementación demuestra cómo DistilBERT puede desplegarse eficazmente en entornos con recursos limitados mientras mantiene un buen rendimiento. El código incluye optimizaciones para el uso de memoria, velocidad de procesamiento y procesamiento eficiente por lotes, haciéndolo adecuado para su implementación en dispositivos con recursos computacionales limitados.

5.1.6 Puntos Clave

BERT (Representaciones Codificadas Bidireccionales de Transformers) trajo un cambio fundamental al PLN al introducir incrustaciones bidireccionales conscientes del contexto. A diferencia de los modelos anteriores que procesaban texto en una dirección, BERT analiza las palabras en relación con todas las demás palabras en una oración simultáneamente. Esta innovación, combinada con su enfoque de pre-entrenamiento/ajuste fino, permite que el modelo desarrolle una comprensión profunda del contexto y matices del lenguaje. Durante el pre-entrenamiento, BERT aprende de cantidades masivas de texto prediciendo palabras enmascaradas y comprendiendo relaciones entre oraciones. Luego, mediante el ajuste fino, puede adaptarse para tareas específicas mientras mantiene su comprensión fundamental del lenguaje.
El éxito de BERT inspiró varias variantes importantes. RoBERTa (Enfoque BERT Robustamente Optimizado) mejoró la arquitectura original modificando el proceso de pre-entrenamiento - usando lotes más grandes de datos, entrenando durante períodos más largos y eliminando la tarea de predicción de la siguiente oración. Estas optimizaciones condujeron a mejoras significativas en el rendimiento. Mientras tanto, DistilBERT abordó los desafíos prácticos de implementación creando una versión más ligera que mantiene la mayoría de las capacidades de BERT mientras usa menos recursos computacionales. Esto se logró mediante la destilación del conocimiento, donde un modelo más pequeño aprende a replicar el comportamiento del modelo más grande, haciendo que las potentes capacidades de PLN sean accesibles para organizaciones con recursos computacionales limitados.
El impacto práctico de estos modelos ha sido notable. En clasificación de texto, logran alta precisión en la categorización de documentos, correos electrónicos y publicaciones en redes sociales. Para respuesta a preguntas, pueden entender consultas complejas y extraer información relevante de textos largos. En análisis de sentimientos, sobresalen en detectar sutiles matices emocionales en el texto. Su versatilidad se extiende a tareas como reconocimiento de entidades nombradas, resumen de texto y traducción de idiomas, donde consistentemente superan los enfoques tradicionales. Esta combinación de alto rendimiento y eficiencia los ha convertido en la base de numerosas aplicaciones del mundo real en industrias que van desde la atención médica hasta el servicio al cliente.

5.1 BERT y sus Variantes (RoBERTa, DistilBERT)

5.1.1 Introducción a BERT

Respuesta a preguntas: Comprensión de consultas complejas y búsqueda de respuestas relevantes en el texto
Análisis de sentimientos: Determinación precisa del tono emocional y la opinión en el texto
Reconocimiento de entidades nombradas: Identificación y clasificación de información clave como nombres, ubicaciones y organizaciones en el texto

5.1.2 Innovaciones Fundamentales de BERT

Contexto Bidireccional

Por ejemplo, considere la oración "La orilla del río está lodosa". En este caso, el procesamiento bidireccional de BERT le permite:

Mirar hacia adelante para ver "lodosa" y "río"
Mirar hacia atrás para entender el contexto de "La"
Combinar estas pistas contextuales para determinar con precisión que "orilla" se refiere a la ribera del río y no a una institución financiera

Ejemplo de Código: Demostrando el Contexto Bidireccional de BERT

from transformers import BertTokenizer, BertForMaskedLM
import torch

# Initialize tokenizer and model
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForMaskedLM.from_pretrained('bert-base-uncased')

# Example sentence with masked token
text = "The [MASK] bank is near the river."

# Tokenize input
inputs = tokenizer(text, return_tensors="pt")

# Get the position of the masked token
mask_token_index = torch.where(inputs["input_ids"] == tokenizer.mask_token_id)[1]

# Get model predictions
with torch.no_grad():
    outputs = model(**inputs)
    predictions = outputs.logits

# Get the predicted token
predicted_token_id = predictions[0, mask_token_index].argmax(axis=-1)
predicted_token = tokenizer.decode(predicted_token_id)

print(f"Original text: {text}")
print(f"Predicted word: {predicted_token}")

# Try another context
text_2 = "I need to deposit money at the [MASK] bank."
inputs_2 = tokenizer(text_2, return_tensors="pt")
mask_token_index_2 = torch.where(inputs_2["input_ids"] == tokenizer.mask_token_id)[1]

with torch.no_grad():
    outputs_2 = model(**inputs_2)
    predictions_2 = outputs_2.logits

predicted_token_id_2 = predictions_2[0, mask_token_index_2].argmax(axis=-1)
predicted_token_2 = tokenizer.decode(predicted_token_id_2)

print(f"\nOriginal text: {text_2}")
print(f"Predicted word: {predicted_token_2}")

Desglose del Código:

Inicialización del Modelo y Tokenizador:

Cargamos el tokenizador de BERT y el modelo de lenguaje enmascarado
Se utiliza la versión 'bert-base-uncased', que tiene un vocabulario de tokens en minúsculas

Procesamiento de Entrada:

Creamos dos oraciones de ejemplo con tokens [MASK]
El tokenizador convierte el texto en representaciones numéricas que BERT puede procesar

Análisis de Contexto Bidireccional:

BERT analiza el contexto tanto a la izquierda como a la derecha del token enmascarado
En el primer ejemplo, "river" influye en la predicción
En el segundo ejemplo, "deposit money" proporciona un contexto diferente

Generación de Predicciones:

El modelo genera distribuciones de probabilidad para todos los tokens posibles
Seleccionamos el token con la probabilidad más alta como predicción

Salida Esperada:

# Output might look like:
Original text: The [MASK] bank is near the river.
Predicted word: river

Original text: I need to deposit money at the [MASK] bank.
Predicted word: local

Paradigma de Pre-entrenamiento y Ajuste Fino

Vocabulario y patrones de uso de palabras
Estructuras y relaciones gramaticales
Significados contextuales de las palabras
Frases y expresiones comunes
Conocimiento básico del mundo incorporado en el lenguaje

Análisis de sentimientos
Respuesta a preguntas
Clasificación de texto
Reconocimiento de entidades nombradas
Resumen de documentos

El proceso costoso y prolongado de pre-entrenamiento solo necesita realizarse una vez
El ajuste fino requiere relativamente pocos datos específicos de la tarea
El proceso puede completarse rápidamente con recursos computacionales mínimos
El modelo resultante mantiene un alto rendimiento al combinar la comprensión amplia del lenguaje con la optimización específica de la tarea

Ejemplo de Código: Pre-entrenamiento y Ajuste Fino de BERT

# 1. Pre-training setup
from transformers import BertConfig, BertForMaskedLM, BertTokenizer
import torch
from torch.utils.data import Dataset, DataLoader

# Custom dataset for pre-training
class PretrainingDataset(Dataset):
    def __init__(self, texts, tokenizer, max_length=512):
        self.encodings = tokenizer(texts, truncation=True, padding='max_length',
                                 max_length=max_length, return_tensors='pt')
        
    def __getitem__(self, idx):
        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
        return item
    
    def __len__(self):
        return len(self.encodings.input_ids)

# Initialize model and tokenizer
config = BertConfig(vocab_size=30522, hidden_size=768)
model = BertForMaskedLM(config)
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# Example pre-training data
pretrain_texts = [
    "The quick brown fox jumps over the lazy dog.",
    "Machine learning is transforming the world of technology."
]

# Create pre-training dataset
pretrain_dataset = PretrainingDataset(pretrain_texts, tokenizer)
pretrain_loader = DataLoader(pretrain_dataset, batch_size=2, shuffle=True)

# Pre-training loop
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)

for epoch in range(3):
    for batch in pretrain_loader:
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

# 2. Fine-tuning for sentiment analysis
from transformers import BertForSequenceClassification

# Convert pre-trained model for classification
model = BertForSequenceClassification.from_pretrained('bert-base-uncased',
                                                     num_labels=2)

# Example fine-tuning data
texts = ["This movie is fantastic!", "The food was terrible."]
labels = torch.tensor([1, 0])  # 1 for positive, 0 for negative

# Prepare fine-tuning data
encodings = tokenizer(texts, truncation=True, padding=True, return_tensors='pt')
dataset = [(encodings, labels)]

# Fine-tuning loop
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)

for epoch in range(3):
    for batch_encodings, batch_labels in dataset:
        outputs = model(**batch_encodings, labels=batch_labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

# 3. Using the fine-tuned model
def predict_sentiment(text):
    inputs = tokenizer(text, return_tensors='pt', truncation=True, padding=True)
    outputs = model(**inputs)
    prediction = torch.argmax(outputs.logits, dim=1)
    return "Positive" if prediction == 1 else "Negative"

# Test the model
test_text = "This is a wonderful example!"
print(f"Sentiment: {predict_sentiment(test_text)}")

Desglose del Código:

Configuración del Pre-entrenamiento (Parte 1):
- Define una clase Dataset personalizada para el manejo de datos de pre-entrenamiento
- Inicializa el modelo BERT con configuración básica
- Crea cargadores de datos para un procesamiento eficiente por lotes
Proceso de Pre-entrenamiento:
- Implementa el bucle de entrenamiento del modelado de lenguaje enmascarado
- Utiliza el optimizador AdamW con tasa de aprendizaje apropiada
- Procesa lotes y actualiza parámetros del modelo
Configuración del Ajuste Fino (Parte 2):
- Convierte el modelo pre-entrenado para clasificación de secuencias
- Prepara el conjunto de datos para análisis de sentimientos
- Implementa el bucle de entrenamiento de ajuste fino
Aplicación del Modelo (Parte 3):
- Crea una función práctica de predicción de sentimientos
- Demuestra cómo usar el modelo ajustado
- Incluye ejemplo de aplicación en el mundo real

Notas Clave de Implementación:

La fase de pre-entrenamiento utiliza modelado de lenguaje enmascarado para aprender patrones generales del lenguaje
El ajuste fino adapta el modelo pre-entrenado para análisis de sentimientos con un entrenamiento adicional mínimo
El ejemplo utiliza un conjunto de datos pequeño para demostración; las aplicaciones reales usarían conjuntos de datos mucho más grandes
Las tasas de aprendizaje se eligen cuidadosamente: más bajas para el ajuste fino (2e-5) que para el pre-entrenamiento (1e-4)

Tokenización con WordPiece

Esta estrategia inteligente de tokenización ofrece varias ventajas clave:

Manejo de vocabulario fuera de registro: BERT puede procesar palabras que no ha encontrado durante el entrenamiento dividiéndolas en subpalabras conocidas
Eficiencia de vocabulario: El modelo puede mantener un vocabulario más pequeño mientras cubre una amplia gama de palabras posibles
Conciencia morfológica: El sistema captura naturalmente prefijos, sufijos y palabras raíz comunes
Capacidades multilingües: Se pueden reconocer partes similares de palabras entre idiomas relacionados
Procesamiento de palabras compuestas: Las palabras complejas y la terminología técnica pueden desglosarse y comprenderse efectivamente

Ejemplo de Código: Tokenización WordPiece

from transformers import BertTokenizer
import pandas as pd

# Initialize the BERT tokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# Example texts with various word types
texts = [
    "immunoelectrophoresis",  # Complex scientific term
    "hyperparameter",         # Technical compound word
    "uncomfortable",          # Word with prefix and suffix
    "pretrained",            # Technical term with prefix
    "3.14159",              # Number
    "AI-powered"            # Hyphenated term
]

# Function to show detailed tokenization
def analyze_tokenization(text):
    # Get tokens and their IDs
    tokens = tokenizer.tokenize(text)
    token_ids = tokenizer.encode(text, add_special_tokens=False)
    
    # Create a detailed breakdown
    return {
        'Original': text,
        'Tokens': tokens,
        'Token IDs': token_ids,
        'Reconstructed': tokenizer.decode(token_ids)
    }

# Analyze each example
results = [analyze_tokenization(text) for text in texts]
df = pd.DataFrame(results)
print(df.to_string())

Desglose del Código:

Inicialización:
- Importamos el tokenizador de BERT desde la biblioteca transformers
- Se utiliza el modelo 'bert-base-uncased', que incluye el vocabulario WordPiece
Selección de Ejemplos:
- Se eligen varios tipos de palabras para demostrar el comportamiento de la tokenización
- Incluye términos científicos, palabras compuestas y caracteres especiales
Función de Análisis:
- El método tokenize() divide las palabras en subpalabras
- encode() convierte los tokens en sus IDs numéricos
- decode() reconstruye el texto original a partir de los IDs

Análisis del Resultado:

# Expected output might look like:
Original: "immunoelectrophoresis"
Tokens: ['imm', '##uno', '##elect', '##ro', '##pho', '##resis']
Token IDs: [2466, 17752, 22047, 2159, 21143, 23875]

Original: "uncomfortable"
Tokens: ['un', '##comfort', '##able']
Token IDs: [2297, 4873, 2137]

Observaciones Clave:

El prefijo '##' indica la continuación de una palabra
Los prefijos comunes (como 'un-') se separan como tokens individuales
Los términos científicos se dividen en subcomponentes significativos
Los números y caracteres especiales reciben un tratamiento especial

Este ejemplo demuestra cómo WordPiece maneja eficazmente varios tipos de palabras mientras mantiene el significado semántico a través de la tokenización inteligente de subpalabras.

5.1.3 Cómo Funciona BERT

Modelado de Lenguaje Enmascarado (MLM):

El proceso de enmascaramiento sigue reglas específicas:

El 80% de los tokens seleccionados se reemplazan con [MASK]
El 10% se reemplazan con palabras aleatorias
El 10% se dejan sin cambios

Esta variedad en el enmascaramiento ayuda a evitar que el modelo dependa demasiado de patrones específicos y asegura un aprendizaje más robusto.

Ejemplo:

Original: "El gato se sentó en la alfombra."
Enmascarado: "El gato se sentó en [MASK] alfombra."
Tarea: El modelo debe predecir "la" usando el contexto de ambas direcciones
Aprendizaje: El modelo aprende relaciones entre palabras y estructuras gramaticales

Ejemplo de Código: Modelado de Lenguaje Enmascarado

import torch
from transformers import BertTokenizer, BertForMaskedLM
import random

# Initialize tokenizer and model
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForMaskedLM.from_pretrained('bert-base-uncased')

def mask_text(text, mask_probability=0.15):
    # Tokenize the input text
    tokens = tokenizer.tokenize(text)
    
    # Decide which tokens to mask
    mask_indices = []
    for i in range(len(tokens)):
        if random.random() < mask_probability:
            mask_indices.append(i)
    
    # Apply masking strategy
    masked_tokens = tokens.copy()
    for idx in mask_indices:
        rand = random.random()
        if rand < 0.8:  # 80% chance to mask
            masked_tokens[idx] = '[MASK]'
        elif rand < 0.9:  # 10% chance to replace with random token
            random_token = tokenizer.convert_ids_to_tokens(
                [random.randint(0, tokenizer.vocab_size)])[0]
            masked_tokens[idx] = random_token
        # 10% chance to keep original token
    
    return tokens, masked_tokens, mask_indices

def predict_masked_tokens(original_tokens, masked_tokens):
    # Convert tokens to input IDs
    inputs = tokenizer.convert_tokens_to_string(masked_tokens)
    inputs = tokenizer(inputs, return_tensors='pt')
    
    # Get model predictions
    with torch.no_grad():
        outputs = model(**inputs)
        predictions = outputs.logits.squeeze()
    
    # Get predictions for masked tokens
    results = []
    for idx in range(len(masked_tokens)):
        if masked_tokens[idx] == '[MASK]':
            predicted_token_id = predictions[idx].argmax().item()
            predicted_token = tokenizer.convert_ids_to_tokens([predicted_token_id])[0]
            results.append({
                'position': idx,
                'original': original_tokens[idx],
                'predicted': predicted_token
            })
    
    return results

# Example usage
text = "The cat sat on the mat while drinking milk."
original_tokens, masked_tokens, mask_indices = mask_text(text)

print("Original:", ' '.join(original_tokens))
print("Masked:", ' '.join(masked_tokens))

predictions = predict_masked_tokens(original_tokens, masked_tokens)
for pred in predictions:
    print(f"Position {pred['position']}: Original '{pred['original']}' → Predicted '{pred['predicted']}'")

Desglose del Código:

Inicialización:
- Carga el modelo BERT preentrenado y el tokenizador específicamente configurado para el modelado de lenguaje enmascarado
- Utiliza 'bert-base-uncased' que tiene un vocabulario de 30,522 tokens
Función de Enmascaramiento (mask_text):
- Implementa la probabilidad de enmascaramiento del 15% de BERT
- Aplica la estrategia de enmascaramiento 80-10-10 (máscara/aleatorio/sin cambios)
- Devuelve tanto las versiones originales como las enmascaradas para comparación
Función de Predicción (predict_masked_tokens):
- Convierte el texto enmascarado en entradas para el modelo
- Utiliza BERT para predecir los tokens más probables para las posiciones enmascaradas
- Devuelve resultados detallados de predicción para análisis

Ejemplo de Salida:

# Sample output might look like:
Original: the cat sat on the mat while drinking milk
Masked: the cat [MASK] on the mat [MASK] drinking milk
Position 2: Original 'sat' → Predicted 'sat'
Position 6: Original 'while' → Predicted 'while'

Notas Clave de Implementación:

El modelo utiliza información contextual de ambas direcciones para hacer predicciones
Las predicciones se basan en distribuciones de probabilidad sobre todo el vocabulario
El proceso de enmascaramiento es aleatorizado para crear ejemplos de entrenamiento diversos
La implementación maneja eficazmente tanto tokens individuales como secuencias más largas

Predicción de la Siguiente Oración (NSP):

Ejemplo:

Oración A: "El gato se sentó en la alfombra."
Oración B: "Era un día soleado."
Resultado: "No Siguiente" (Las oraciones no están relacionadas)

Ejemplo de Código: Predicción de la Siguiente Oración

from transformers import BertTokenizer, BertForNextSentencePrediction
import torch

def check_sentence_pair(sentence_a, sentence_b):
    # Initialize tokenizer and model
    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
    model = BertForNextSentencePrediction.from_pretrained('bert-base-uncased')
    
    # Encode the sentence pair
    encoding = tokenizer(
        sentence_a,
        sentence_b,
        return_tensors='pt',
        max_length=512,
        truncation=True,
        padding='max_length'
    )
    
    # Get model prediction
    with torch.no_grad():
        outputs = model(**encoding)
        logits = outputs.logits
        prob = torch.softmax(logits, dim=1)
        
        # prob[0][0] = probability of "NotNext"
        # prob[0][1] = probability of "IsNext"
        is_next_prob = prob[0][1].item()
    
    return is_next_prob

# Example sentence pairs
sentence_pairs = [
    # Related pair (should be "IsNext")
    ("The cat sat on the mat.", "It was feeling sleepy and comfortable."),
    
    # Unrelated pair (should be "NotNext")
    ("The weather is beautiful today.", "Quantum physics explains particle behavior."),
    
    # Related pair with context
    ("Scientists discovered a new species.", "The findings were published in Nature journal."),
]

# Test each pair
for sent_a, sent_b in sentence_pairs:
    prob = check_sentence_pair(sent_a, sent_b)
    print(f"\nSentence A: {sent_a}")
    print(f"Sentence B: {sent_b}")
    print(f"Probability of B following A: {prob:.2%}")
    print(f"Prediction: {'IsNext' if prob > 0.5 else 'NotNext'}")

Desglose del Código:

Configuración del Modelo:
- Inicializa el tokenizador de BERT y el modelo NSP especializado
- Utiliza 'bert-base-uncased' que está preentrenado en tareas NSP
Procesamiento de Entrada:
- Tokeniza ambas oraciones con tokens especiales ([CLS], [SEP])
- Gestiona el relleno y truncamiento para mantener un tamaño de entrada consistente
- Devuelve tensores adecuados para el procesamiento de BERT
Predicción:
- El modelo genera logits que representan probabilidades para IsNext/NotNext
- Softmax convierte los logits en probabilidades entre 0 y 1
- Devuelve la probabilidad de que las oraciones sean consecutivas

Ejemplo de Salida:

# Expected output:
Sentence A: The cat sat on the mat.
Sentence B: It was feeling sleepy and comfortable.
Probability of B following A: 87.65%
Prediction: IsNext

Sentence A: The weather is beautiful today.
Sentence B: Quantum physics explains particle behavior.
Probability of B following A: 12.34%
Prediction: NotNext

Notas Clave de Implementación:

El modelo considera tanto las relaciones semánticas como contextuales entre oraciones
Las probabilidades más cercanas a 1 indican una mayor probabilidad de que las oraciones sean consecutivas
Se utiliza un umbral de 0.5 para tomar decisiones binarias de EsSiguiente/NoEsSiguiente
El modelo puede manejar varios tipos de relaciones, desde continuaciones directas hasta coherencia temática

5.1.4 Variantes de BERT

RoBERTa (Enfoque de Pre-entrenamiento de BERT Robustamente Optimizado)

Elimina la tarea de Predicción de la Siguiente Oración (NSP) para centrarse únicamente en el Modelado de Lenguaje Enmascarado (MLM):
- La investigación mostró que los beneficios de NSP eran mínimos en comparación con MLM
- Centrarse en MLM permite un entrenamiento más eficiente y una mejor comprensión del lenguaje
Entrena con más datos y tamaños de lote más grandes:
- Utiliza 160GB de texto en comparación con los 16GB de BERT
- Implementa tamaños de lote más grandes (8K tokens) para un entrenamiento más estable
- Entrena durante períodos más largos para lograr una mejor convergencia del modelo
Utiliza enmascaramiento dinámico para proporcionar ejemplos de entrenamiento variados:
- BERT utilizaba enmascaramiento estático aplicado una vez durante el preprocesamiento de datos
- RoBERTa genera nuevos patrones de enmascaramiento cada vez que se alimenta una secuencia al modelo
- Esto evita que el modelo memorice patrones específicos y mejora la generalización

Beneficios Principales:

Mejor rendimiento en puntos de referencia de PLN:
- Supera consistentemente a BERT en los puntos de referencia GLUE, SQuAD y RACE
- Muestra mejoras significativas en tareas de razonamiento complejo
Mayor robustez y precisión en tareas derivadas:
- Proceso de ajuste fino más estable
- Mejores capacidades de transferencia de aprendizaje para tareas de dominio específico
- Mejor rendimiento en escenarios de recursos limitados

Ejemplo de Código: Uso de RoBERTa para Clasificación de Texto

from transformers import RobertaTokenizer, RobertaForSequenceClassification
import torch
from torch.utils.data import Dataset, DataLoader

# Initialize tokenizer and model
tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
model = RobertaForSequenceClassification.from_pretrained('roberta-base', num_labels=2)

class TextDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, 
                                 max_length=max_length, return_tensors='pt')
        self.labels = torch.tensor(labels)

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = self.labels[idx]
        return item

    def __len__(self):
        return len(self.labels)

# Example training data
texts = [
    "This movie was absolutely fantastic!",
    "The plot was confusing and boring.",
    "A masterpiece of modern cinema.",
    "Waste of time and money."
]
labels = [1, 0, 1, 0]  # 1 for positive, 0 for negative

# Create dataset and dataloader
dataset = TextDataset(texts, labels, tokenizer)
loader = DataLoader(dataset, batch_size=2, shuffle=True)

# Training setup
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-5)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)

# Training loop
def train(epochs=3):
    model.train()
    for epoch in range(epochs):
        total_loss = 0
        for batch in loader:
            optimizer.zero_grad()
            
            # Move batch to device
            input_ids = batch['input_ids'].to(device)
            attention_mask = batch['attention_mask'].to(device)
            labels = batch['labels'].to(device)
            
            # Forward pass
            outputs = model(input_ids, attention_mask=attention_mask, 
                          labels=labels)
            loss = outputs.loss
            
            # Backward pass
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
            
        print(f"Epoch {epoch+1}, Average loss: {total_loss/len(loader)}")

# Prediction function
def predict(text):
    model.eval()
    with torch.no_grad():
        inputs = tokenizer(text, return_tensors='pt', 
                         truncation=True, padding=True).to(device)
        outputs = model(**inputs)
        predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
        return predictions.cpu().numpy()

# Train the model
train()

# Example prediction
test_text = "This is an amazing example of natural language processing!"
prediction = predict(test_text)
print(f"Prediction probabilities: Negative: {prediction[0][0]:.3f}, Positive: {prediction[0][1]:.3f}")

Desglose del Código:

Inicialización del Modelo y Tokenizador:
- Utiliza el tokenizador y modelo pre-entrenado de RoBERTa para clasificación de secuencias
- Configura el modelo para clasificación binaria (positivo/negativo)
Implementación del Dataset Personalizado:
- Crea una clase Dataset de PyTorch para el manejo eficiente de datos
- Gestiona la tokenización y conversión a tensores
- Implementa los métodos requeridos de Dataset de PyTorch (__getitem__, __len__)
Pipeline de Entrenamiento:
- Utiliza el optimizador AdamW con una tasa de aprendizaje pequeña para el ajuste fino
- Implementa entrenamiento independiente del dispositivo (CPU/GPU)
- Incluye un bucle completo de entrenamiento con seguimiento de pérdida
Función de Predicción:
- Implementa pipeline de inferencia para entradas de texto individuales
- Devuelve distribuciones de probabilidad para clasificación
- Maneja todo el preprocesamiento necesario automáticamente

Notas Clave de Implementación:

RoBERTa utiliza un enfoque de tokenización diferente al de BERT, optimizado para mejor rendimiento
El modelo maneja automáticamente el relleno y truncamiento para longitudes variables de texto
La implementación incluye gestión adecuada de memoria con puesta a cero de gradientes y procesamiento por lotes
El código demuestra tanto las fases de entrenamiento como de inferencia del modelo

DistilBERT:

El proceso de destilación equilibra cuidadosamente tres objetivos clave de entrenamiento:

Hacer coincidir las probabilidades objetivo suaves producidas por el modelo maestro
Mantener el mismo objetivo de modelado de lenguaje enmascarado que BERT
Preservar la similitud del coseno entre los estados ocultos del maestro y el estudiante
A través de estas optimizaciones, DistilBERT logra mejoras notables en eficiencia:
- 40% de reducción en el tamaño del modelo (de 110M a 66M parámetros)
- 60% más velocidad de procesamiento durante la inferencia
- Mantiene el 97% de las capacidades de comprensión del lenguaje de BERT

Beneficios Principales:

Ideal para implementación en entornos con recursos limitados:
- Adecuado para dispositivos móviles y computación en el borde
- La huella de memoria reducida permite más opciones de implementación
- Menores requisitos computacionales significan menor consumo de energía
Inferencia más rápida con pérdida mínima de rendimiento:
- Permite aplicaciones en tiempo real y mayor rendimiento
- Mantiene alta precisión en la mayoría de tareas de PLN
- Más rentable para implementaciones a gran escala

Ejemplo de Código: Uso de DistilBERT para Clasificación de Texto

from transformers import DistilBertTokenizer, DistilBertForSequenceClassification
import torch
from torch.utils.data import Dataset, DataLoader

# Initialize tokenizer and model
tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')
model = DistilBertForSequenceClassification.from_pretrained('distilbert-base-uncased', num_labels=2)

class TextClassificationDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, 
                                 max_length=max_length, return_tensors='pt')
        self.labels = torch.tensor(labels)

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = self.labels[idx]
        return item

    def __len__(self):
        return len(self.labels)

# Example data
texts = [
    "This product exceeded my expectations!",
    "Very disappointed with the quality.",
    "Great value for money, highly recommend.",
    "Customer service was terrible."
]
labels = [1, 0, 1, 0]  # 1: Positive, 0: Negative

# Create dataset and dataloader
dataset = TextClassificationDataset(texts, labels, tokenizer)
loader = DataLoader(dataset, batch_size=2, shuffle=True)

# Training configuration
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5)
num_epochs = 3

# Training loop
def train_model():
    model.train()
    for epoch in range(num_epochs):
        total_loss = 0
        for batch in loader:
            optimizer.zero_grad()
            
            # Move batch to device
            input_ids = batch['input_ids'].to(device)
            attention_mask = batch['attention_mask'].to(device)
            labels = batch['labels'].to(device)
            
            # Forward pass
            outputs = model(input_ids, attention_mask=attention_mask, 
                          labels=labels)
            loss = outputs.loss
            
            # Backward pass and optimization
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
        
        avg_loss = total_loss / len(loader)
        print(f"Epoch {epoch + 1}/{num_epochs}, Average Loss: {avg_loss:.4f}")

# Inference function
def predict_sentiment(text):
    model.eval()
    with torch.no_grad():
        inputs = tokenizer(text, return_tensors='pt', 
                         truncation=True, padding=True).to(device)
        outputs = model(**inputs)
        probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
        return probs.cpu().numpy()[0]

# Train the model
train_model()

# Example prediction
test_text = "The customer support team was very helpful!"
prediction = predict_sentiment(test_text)
print(f"\nTest text: {test_text}")
print(f"Sentiment prediction: Negative: {prediction[0]:.3f}, Positive: {prediction[1]:.3f}")

Desglose del Código:

Configuración del Modelo y Tokenizador:
- Inicializa el tokenizador y modelo de clasificación de DistilBERT
- Utiliza el modelo pre-entrenado 'distilbert-base-uncased'
- Configura para clasificación binaria (sentimiento positivo/negativo)
Implementación del Dataset Personalizado:
- Crea una clase Dataset de PyTorch para el manejo eficiente de datos
- Gestiona la tokenización y conversión a tensores
- Implementa los métodos requeridos de Dataset para compatibilidad con PyTorch
Pipeline de Entrenamiento:
- Utiliza el optimizador AdamW con una tasa de aprendizaje de 5e-5
- Implementa entrenamiento independiente del dispositivo (CPU/GPU)
- Incluye seguimiento de pérdida y reporte de progreso por época
Implementación de Inferencia:
- Proporciona una función dedicada de predicción para entradas de texto individuales
- Devuelve distribuciones de probabilidad para clasificación binaria
- Maneja automáticamente todos los pasos necesarios de preprocesamiento

Notas Clave de Implementación:

El código demuestra la eficiencia de DistilBERT mientras mantiene el rendimiento similar a BERT
La implementación incluye gestión adecuada de memoria y procesamiento por lotes
El modelo maneja automáticamente el preprocesamiento y tokenización del texto
Muestra tanto las fases de entrenamiento como de inferencia con ejemplos prácticos

Ejemplo Práctico: Uso de BERT y sus Variantes

Usemos Hugging Face Transformers para cargar y ajustar BERT, RoBERTa y DistilBERT para una tarea de clasificación de texto.

Ejemplo de Código: Ajuste Fino de BERT para Análisis de Sentimiento

from transformers import BertTokenizer, BertForSequenceClassification, Trainer, TrainingArguments
from torch.utils.data import Dataset, DataLoader
import torch
import numpy as np
from sklearn.metrics import accuracy_score, precision_recall_fscore_support

# Custom Dataset Class
class SentimentDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, 
                                 max_length=max_length, return_tensors="pt")
        self.labels = torch.tensor(labels)

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = self.labels[idx]
        return item

# Metrics computation function
def compute_metrics(pred):
    labels = pred.label_ids
    preds = pred.predictions.argmax(-1)
    precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='binary')
    acc = accuracy_score(labels, preds)
    return {
        'accuracy': acc,
        'f1': f1,
        'precision': precision,
        'recall': recall
    }

# Load pre-trained BERT and tokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
model = BertForSequenceClassification.from_pretrained(
    "bert-base-uncased",
    num_labels=2,
    output_attentions=True
)

# Example data
texts = [
    "The movie was fantastic!",
    "I did not enjoy the food.",
    "This is the best book I've ever read!",
    "The service was terrible and slow.",
    "Absolutely loved the experience!"
]
labels = [1, 0, 1, 0, 1]  # 1 = Positive, 0 = Negative

# Create datasets
train_dataset = SentimentDataset(texts, labels, tokenizer)

# Define training arguments
training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
    logging_dir='./logs',
    logging_steps=10,
    load_best_model_at_end=True,
    metric_for_best_model='f1',
    save_strategy="epoch"
)

# Initialize trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    compute_metrics=compute_metrics
)

# Train the model
trainer.train()

# Example inference
def predict_sentiment(text):
    # Prepare input
    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
    
    # Get prediction
    with torch.no_grad():
        outputs = model(**inputs)
        probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
        prediction = torch.argmax(probabilities, dim=-1)
    
    return {
        "text": text,
        "sentiment": "Positive" if prediction == 1 else "Negative",
        "confidence": float(probabilities[0][prediction])
    }

# Test predictions
test_texts = [
    "I would highly recommend this product!",
    "This was a complete waste of money."
]

for text in test_texts:
    result = predict_sentiment(text)
    print(f"\nText: {result['text']}")
    print(f"Sentiment: {result['sentiment']}")
    print(f"Confidence: {result['confidence']:.4f}")

Desglose y Explicación del Código:

Implementación del Dataset Personalizado:
- Crea una clase Dataset personalizada de PyTorch (SentimentDataset)
- Maneja la tokenización y conversión de datos de texto a tensores
- Implementa los métodos requeridos de Dataset (__len__, __getitem__)
Configuración y Preparación del Modelo:
- Inicializa el tokenizador y modelo de clasificación BERT
- Configura para clasificación binaria de sentimientos
- Habilita las salidas de atención para análisis potencial
Configuración del Entrenamiento:
- Define argumentos completos de entrenamiento
- Implementa configuraciones de tasa de aprendizaje y tamaño de lote
- Incluye estrategias de registro y guardado del modelo
Métricas y Evaluación:
- Implementa la función compute_metrics para seguimiento del rendimiento
- Calcula precisión, puntuación F1, precisión y exhaustividad
- Permite la evaluación del modelo durante el entrenamiento
Pipeline de Inferencia:
- Crea una función dedicada de predicción
- Maneja entradas de texto individuales con preprocesamiento adecuado
- Devuelve resultados detallados de predicción con puntuaciones de confianza

5.1.5 Casos de Uso Clave de BERT y sus Variantes

Clasificación de Texto:

Respuesta a Preguntas:

La destreza del modelo en respuesta a preguntas proviene de su capacidad para:

Procesar relaciones semánticas entre palabras y frases a través de largas distancias en el texto
Comprender diversos tipos de preguntas, desde consultas factuales hasta preguntas de razonamiento más abstracto
Considerar múltiples niveles de contexto simultáneamente, desde la comprensión a nivel de palabra hasta nivel de oración
Generar respuestas contextualmente apropiadas sintetizando información de diferentes partes del pasaje

Ejemplo de Código: Respuesta a Preguntas con BERT

from transformers import AutoTokenizer, AutoModelForQuestionAnswering
import torch

def setup_qa_model():
    # Initialize tokenizer and model
    tokenizer = AutoTokenizer.from_pretrained("bert-large-uncased-whole-word-masking-finetuned-squad")
    model = AutoModelForQuestionAnswering.from_pretrained("bert-large-uncased-whole-word-masking-finetuned-squad")
    return tokenizer, model

def answer_question(question, context, tokenizer, model):
    # Tokenize input text
    inputs = tokenizer(
        question,
        context,
        add_special_tokens=True,
        return_tensors="pt",
        max_length=512,
        truncation=True,
        padding='max_length'
    )
    
    # Get model predictions
    with torch.no_grad():
        outputs = model(**inputs)
        answer_start = outputs.start_logits.argmax()
        answer_end = outputs.end_logits.argmax()
    
    # Convert token positions to text
    tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
    answer = tokenizer.convert_tokens_to_string(tokens[answer_start:answer_end + 1])
    
    # Calculate confidence scores
    start_scores = torch.softmax(outputs.start_logits, dim=1)[0]
    end_scores = torch.softmax(outputs.end_logits, dim=1)[0]
    confidence = float((start_scores[answer_start] * end_scores[answer_end]).item())
    
    return {
        "answer": answer,
        "confidence": confidence,
        "start": answer_start,
        "end": answer_end
    }

# Example usage
tokenizer, model = setup_qa_model()

context = """
The Transformer architecture was introduced in the paper 'Attention Is All You Need' 
by Vaswani et al. in 2017. BERT, which stands for Bidirectional Encoder Representations 
from Transformers, was developed by researchers at Google AI Language in 2018. It 
revolutionized NLP by introducing bidirectional training and achieving state-of-the-art 
results on various language tasks.
"""

questions = [
    "When was the Transformer architecture introduced?",
    "Who developed BERT?",
    "What does BERT stand for?"
]

for question in questions:
    result = answer_question(question, context, tokenizer, model)
    print(f"\nQuestion: {question}")
    print(f"Answer: {result['answer']}")
    print(f"Confidence: {result['confidence']:.4f}")

Desglose del código:

Configuración e Inicialización del Modelo:
- Utiliza un modelo BERT pre-entrenado específicamente ajustado para responder preguntas en el conjunto de datos SQuAD
- Inicializa tanto el tokenizador como el modelo desde la biblioteca transformers de Hugging Face
Implementación de la Función de Respuesta a Preguntas:
- Maneja el preprocesamiento de entrada con tokenización adecuada
- Gestiona la longitud máxima de secuencia y el truncamiento
- Implementa procesamiento por lotes eficiente con PyTorch
Proceso de Extracción de Respuestas:
- Identifica las posiciones de inicio y fin de la respuesta en el texto
- Convierte las posiciones de tokens a texto legible
- Calcula puntuaciones de confianza para las predicciones
Procesamiento de Resultados:
- Devuelve una salida estructurada con la respuesta, puntuación de confianza e información de posición
- Maneja casos extremos y posibles errores en la extracción de respuestas
- Proporciona métricas de confianza significativas para la fiabilidad de las respuestas

Reconocimiento de Entidades Nombradas (NER)

Nombres de personas, incluyendo variaciones y apodos
Expresiones temporales como fechas, horas y duraciones
Ubicaciones geográficas a diferentes escalas (ciudades, países, puntos de referencia)
Nombres de organizaciones, incluyendo empresas, instituciones y organismos gubernamentales
Nombres de productos y marcas en diferentes industrias
Valores monetarios en varias monedas y formatos
Entidades personalizadas específicas para dominios o industrias particulares

Esta sofisticada funcionalidad de reconocimiento de entidades sirve como piedra angular para numerosas aplicaciones prácticas:

Revisión de Documentos Legales: Identificación automática de partes, fechas, montos monetarios y entidades legales
Análisis de Registros Médicos: Extracción de información del paciente, condiciones médicas, medicamentos y fechas de tratamiento
Inteligencia Empresarial: Seguimiento de menciones de empresas, referencias de productos y tendencias del mercado
Investigación y Academia: Identificación de citas, nombres de autores y afiliaciones institucionales
Análisis Financiero: Detección de nombres de empresas, valores monetarios y detalles de transacciones
Noticias y Medios: Categorización de personas, organizaciones y ubicaciones en artículos de noticias

Ejemplo de Código: Reconocimiento de Entidades Nombradas con BERT

from transformers import AutoTokenizer, AutoModelForTokenClassification
import torch
from torch.nn import functional as F

def setup_ner_model():
    # Initialize tokenizer and model for NER
    tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")
    model = AutoModelForTokenClassification.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")
    return tokenizer, model

def perform_ner(text, tokenizer, model):
    # Tokenize input text
    inputs = tokenizer(
        text,
        add_special_tokens=True,
        return_tensors="pt",
        truncation=True,
        max_length=512
    )
    
    # Get predictions
    with torch.no_grad():
        outputs = model(**inputs)
        predictions = F.softmax(outputs.logits, dim=-1)
        predictions = torch.argmax(predictions, dim=-1)
    
    # Process tokens and predictions
    tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
    label_list = model.config.id2label
    
    entities = []
    current_entity = None
    
    for idx, (token, pred) in enumerate(zip(tokens, predictions[0])):
        label = label_list[pred.item()]
        
        # Skip special tokens
        if token in [tokenizer.sep_token, tokenizer.cls_token, tokenizer.pad_token]:
            continue
            
        # Handle B- (beginning) and I- (inside) tags
        if label.startswith("B-"):
            if current_entity:
                entities.append(current_entity)
            current_entity = {
                "entity": token.replace("##", ""),
                "type": label[2:],
                "start": idx
            }
        elif label.startswith("I-") and current_entity:
            current_entity["entity"] += token.replace("##", "")
        elif label == "O":  # Outside any entity
            if current_entity:
                entities.append(current_entity)
                current_entity = None
    
    if current_entity:
        entities.append(current_entity)
    
    return entities

# Example usage
def demonstrate_ner():
    tokenizer, model = setup_ner_model()
    
    sample_text = """
    Apple Inc. CEO Tim Cook announced a new partnership with Microsoft 
    Corporation in New York City last Friday. The deal, worth $5 billion, 
    will help both companies expand their presence in the artificial 
    intelligence market.
    """
    
    entities = perform_ner(sample_text, tokenizer, model)
    
    # Print results
    for entity in entities:
        print(f"Entity: {entity['entity']}")
        print(f"Type: {entity['type']}")
        print("---")

Desglose y Explicación del Código:

Inicialización y Configuración del Modelo:
- Utiliza un modelo BERT pre-entrenado específicamente ajustado para tareas de NER
- Aprovecha la biblioteca transformers de Hugging Face para la configuración del modelo y tokenizador
- Configura el modelo para la clasificación de tokens con etiquetas de entidades
Función de Procesamiento NER:
- Implementa tokenización eficiente con manejo adecuado de tokens especiales
- Gestiona limitaciones de longitud de secuencia y truncamiento
- Utiliza el contexto no_grad de PyTorch para inferencia eficiente
Reconocimiento y Procesamiento de Entidades:
- Maneja el esquema de etiquetado BIO (Principio, Dentro, Fuera)
- Procesa tokens parciales y reconstruye entidades completas
- Mantiene con precisión los límites y tipos de entidades
Procesamiento de Salida:
- Crea una salida estructurada con texto de entidad, tipo e información de posición
- Maneja casos extremos y reconstrucción de tokens
- Proporciona resultados limpios y organizados de extracción de entidades

Tareas con Recursos Limitados:

Los logros clave de DistilBERT son impresionantes:

Retención de Rendimiento: Preserva aproximadamente el 97% de las capacidades de comprensión del lenguaje de BERT, asegurando resultados de alta calidad
Optimización de Tamaño: El modelo logra una reducción del 40% en tamaño comparado con BERT, requiriendo significativamente menos espacio de almacenamiento
Mejora de Velocidad: La velocidad de procesamiento aumenta en un 60%, permitiendo tiempos de inferencia más rápidos y mejor capacidad de respuesta

Estas mejoras hacen que DistilBERT sea particularmente valioso para varias aplicaciones del mundo real:

Aplicaciones Móviles: Permite características sofisticadas de PLN en smartphones y tablets sin consumo excesivo de batería o requisitos de almacenamiento
Computación de Borde: Permite el procesamiento local en dispositivos IoT y servidores edge, reduciendo la necesidad de conectividad en la nube
Sistemas en Tiempo Real: Admite aplicaciones que requieren respuestas inmediatas, como traducción en vivo o análisis de mensajes instantáneos
Entornos con Recursos Limitados: Hace el PLN avanzado accesible en entornos con poder computacional o memoria limitados

Ejemplo de Código: Tareas con Recursos Limitados usando DistilBERT

from transformers import DistilBertTokenizer, DistilBertForSequenceClassification
import torch
from torch.nn import functional as F

def setup_distilbert():
    # Initialize tokenizer and model
    tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')
    model = DistilBertForSequenceClassification.from_pretrained(
        'distilbert-base-uncased',
        num_labels=2  # Binary classification
    )
    return tokenizer, model

def optimize_model_for_inference(model):
    # Convert to inference mode
    model.eval()
    # Quantize model to reduce memory footprint
    model = torch.quantization.quantize_dynamic(
        model, {torch.nn.Linear}, dtype=torch.qint8
    )
    return model

def process_text(text, tokenizer, model, max_length=128):
    # Tokenize with truncation
    inputs = tokenizer(
        text,
        truncation=True,
        max_length=max_length,
        padding='max_length',
        return_tensors='pt'
    )
    
    # Efficient inference
    with torch.no_grad():
        outputs = model(**inputs)
        predictions = F.softmax(outputs.logits, dim=-1)
    
    return predictions

def batch_process_texts(texts, tokenizer, model, batch_size=16):
    results = []
    
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        batch_predictions = process_text(batch, tokenizer, model)
        results.extend(batch_predictions.tolist())
    
    return results

# Example usage
def demonstrate_resource_constrained_classification():
    tokenizer, model = setup_distilbert()
    model = optimize_model_for_inference(model)
    
    sample_texts = [
        "This product works great and I'm very satisfied!",
        "The quality is terrible, would not recommend.",
        "Decent product for the price point."
    ]
    
    predictions = batch_process_texts(sample_texts, tokenizer, model)
    
    for text, pred in zip(sample_texts, predictions):
        sentiment = "Positive" if pred[1] > 0.5 else "Negative"
        confidence = max(pred)
        print(f"Text: {text}")
        print(f"Sentiment: {sentiment} (Confidence: {confidence:.2f})")
        print("---")

Desglose del Código:

Configuración y Optimización del Modelo:
- Inicializa DistilBERT con una configuración mínima para clasificación de secuencias
- Implementa la cuantización del modelo para reducir el uso de memoria
- Configura el modelo para un modo de inferencia eficiente
Función de Procesamiento de Texto:
- Implementa tokenización eficiente con restricciones de longitud
- Utiliza procesamiento por lotes dinámico para un uso óptimo de recursos
- Gestiona la memoria eficientemente con el contexto no_grad
Técnicas de Optimización de Recursos:
- Emplea cuantización del modelo para reducir la huella de memoria
- Implementa procesamiento por lotes para maximizar el rendimiento
- Utiliza estrategias de truncamiento y relleno para gestionar longitudes de secuencia
Consideraciones de Rendimiento:
- Equilibra el tamaño del lote con las restricciones de memoria
- Implementa agregación eficiente de predicciones
- Proporciona puntuaciones de confianza para la fiabilidad de las predicciones

5.1.6 Puntos Clave

BERT (Representaciones Codificadas Bidireccionales de Transformers) trajo un cambio fundamental al PLN al introducir incrustaciones bidireccionales conscientes del contexto. A diferencia de los modelos anteriores que procesaban texto en una dirección, BERT analiza las palabras en relación con todas las demás palabras en una oración simultáneamente. Esta innovación, combinada con su enfoque de pre-entrenamiento/ajuste fino, permite que el modelo desarrolle una comprensión profunda del contexto y matices del lenguaje. Durante el pre-entrenamiento, BERT aprende de cantidades masivas de texto prediciendo palabras enmascaradas y comprendiendo relaciones entre oraciones. Luego, mediante el ajuste fino, puede adaptarse para tareas específicas mientras mantiene su comprensión fundamental del lenguaje.
El éxito de BERT inspiró varias variantes importantes. RoBERTa (Enfoque BERT Robustamente Optimizado) mejoró la arquitectura original modificando el proceso de pre-entrenamiento - usando lotes más grandes de datos, entrenando durante períodos más largos y eliminando la tarea de predicción de la siguiente oración. Estas optimizaciones condujeron a mejoras significativas en el rendimiento. Mientras tanto, DistilBERT abordó los desafíos prácticos de implementación creando una versión más ligera que mantiene la mayoría de las capacidades de BERT mientras usa menos recursos computacionales. Esto se logró mediante la destilación del conocimiento, donde un modelo más pequeño aprende a replicar el comportamiento del modelo más grande, haciendo que las potentes capacidades de PLN sean accesibles para organizaciones con recursos computacionales limitados.
El impacto práctico de estos modelos ha sido notable. En clasificación de texto, logran alta precisión en la categorización de documentos, correos electrónicos y publicaciones en redes sociales. Para respuesta a preguntas, pueden entender consultas complejas y extraer información relevante de textos largos. En análisis de sentimientos, sobresalen en detectar sutiles matices emocionales en el texto. Su versatilidad se extiende a tareas como reconocimiento de entidades nombradas, resumen de texto y traducción de idiomas, donde consistentemente superan los enfoques tradicionales. Esta combinación de alto rendimiento y eficiencia los ha convertido en la base de numerosas aplicaciones del mundo real en industrias que van desde la atención médica hasta el servicio al cliente.

5.1 BERT y sus Variantes (RoBERTa, DistilBERT)

5.1.1 Introducción a BERT

Respuesta a preguntas: Comprensión de consultas complejas y búsqueda de respuestas relevantes en el texto
Análisis de sentimientos: Determinación precisa del tono emocional y la opinión en el texto
Reconocimiento de entidades nombradas: Identificación y clasificación de información clave como nombres, ubicaciones y organizaciones en el texto

5.1.2 Innovaciones Fundamentales de BERT

Contexto Bidireccional

Por ejemplo, considere la oración "La orilla del río está lodosa". En este caso, el procesamiento bidireccional de BERT le permite:

Mirar hacia adelante para ver "lodosa" y "río"
Mirar hacia atrás para entender el contexto de "La"
Combinar estas pistas contextuales para determinar con precisión que "orilla" se refiere a la ribera del río y no a una institución financiera

Ejemplo de Código: Demostrando el Contexto Bidireccional de BERT

from transformers import BertTokenizer, BertForMaskedLM
import torch

# Initialize tokenizer and model
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForMaskedLM.from_pretrained('bert-base-uncased')

# Example sentence with masked token
text = "The [MASK] bank is near the river."

# Tokenize input
inputs = tokenizer(text, return_tensors="pt")

# Get the position of the masked token
mask_token_index = torch.where(inputs["input_ids"] == tokenizer.mask_token_id)[1]

# Get model predictions
with torch.no_grad():
    outputs = model(**inputs)
    predictions = outputs.logits

# Get the predicted token
predicted_token_id = predictions[0, mask_token_index].argmax(axis=-1)
predicted_token = tokenizer.decode(predicted_token_id)

print(f"Original text: {text}")
print(f"Predicted word: {predicted_token}")

# Try another context
text_2 = "I need to deposit money at the [MASK] bank."
inputs_2 = tokenizer(text_2, return_tensors="pt")
mask_token_index_2 = torch.where(inputs_2["input_ids"] == tokenizer.mask_token_id)[1]

with torch.no_grad():
    outputs_2 = model(**inputs_2)
    predictions_2 = outputs_2.logits

predicted_token_id_2 = predictions_2[0, mask_token_index_2].argmax(axis=-1)
predicted_token_2 = tokenizer.decode(predicted_token_id_2)

print(f"\nOriginal text: {text_2}")
print(f"Predicted word: {predicted_token_2}")

Desglose del Código:

Inicialización del Modelo y Tokenizador:

Cargamos el tokenizador de BERT y el modelo de lenguaje enmascarado
Se utiliza la versión 'bert-base-uncased', que tiene un vocabulario de tokens en minúsculas

Procesamiento de Entrada:

Creamos dos oraciones de ejemplo con tokens [MASK]
El tokenizador convierte el texto en representaciones numéricas que BERT puede procesar

Análisis de Contexto Bidireccional:

BERT analiza el contexto tanto a la izquierda como a la derecha del token enmascarado
En el primer ejemplo, "river" influye en la predicción
En el segundo ejemplo, "deposit money" proporciona un contexto diferente

Generación de Predicciones:

El modelo genera distribuciones de probabilidad para todos los tokens posibles
Seleccionamos el token con la probabilidad más alta como predicción

Salida Esperada:

# Output might look like:
Original text: The [MASK] bank is near the river.
Predicted word: river

Original text: I need to deposit money at the [MASK] bank.
Predicted word: local

Paradigma de Pre-entrenamiento y Ajuste Fino

Vocabulario y patrones de uso de palabras
Estructuras y relaciones gramaticales
Significados contextuales de las palabras
Frases y expresiones comunes
Conocimiento básico del mundo incorporado en el lenguaje

Análisis de sentimientos
Respuesta a preguntas
Clasificación de texto
Reconocimiento de entidades nombradas
Resumen de documentos

El proceso costoso y prolongado de pre-entrenamiento solo necesita realizarse una vez
El ajuste fino requiere relativamente pocos datos específicos de la tarea
El proceso puede completarse rápidamente con recursos computacionales mínimos
El modelo resultante mantiene un alto rendimiento al combinar la comprensión amplia del lenguaje con la optimización específica de la tarea

Ejemplo de Código: Pre-entrenamiento y Ajuste Fino de BERT

# 1. Pre-training setup
from transformers import BertConfig, BertForMaskedLM, BertTokenizer
import torch
from torch.utils.data import Dataset, DataLoader

# Custom dataset for pre-training
class PretrainingDataset(Dataset):
    def __init__(self, texts, tokenizer, max_length=512):
        self.encodings = tokenizer(texts, truncation=True, padding='max_length',
                                 max_length=max_length, return_tensors='pt')
        
    def __getitem__(self, idx):
        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
        return item
    
    def __len__(self):
        return len(self.encodings.input_ids)

# Initialize model and tokenizer
config = BertConfig(vocab_size=30522, hidden_size=768)
model = BertForMaskedLM(config)
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# Example pre-training data
pretrain_texts = [
    "The quick brown fox jumps over the lazy dog.",
    "Machine learning is transforming the world of technology."
]

# Create pre-training dataset
pretrain_dataset = PretrainingDataset(pretrain_texts, tokenizer)
pretrain_loader = DataLoader(pretrain_dataset, batch_size=2, shuffle=True)

# Pre-training loop
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)

for epoch in range(3):
    for batch in pretrain_loader:
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

# 2. Fine-tuning for sentiment analysis
from transformers import BertForSequenceClassification

# Convert pre-trained model for classification
model = BertForSequenceClassification.from_pretrained('bert-base-uncased',
                                                     num_labels=2)

# Example fine-tuning data
texts = ["This movie is fantastic!", "The food was terrible."]
labels = torch.tensor([1, 0])  # 1 for positive, 0 for negative

# Prepare fine-tuning data
encodings = tokenizer(texts, truncation=True, padding=True, return_tensors='pt')
dataset = [(encodings, labels)]

# Fine-tuning loop
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)

for epoch in range(3):
    for batch_encodings, batch_labels in dataset:
        outputs = model(**batch_encodings, labels=batch_labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

# 3. Using the fine-tuned model
def predict_sentiment(text):
    inputs = tokenizer(text, return_tensors='pt', truncation=True, padding=True)
    outputs = model(**inputs)
    prediction = torch.argmax(outputs.logits, dim=1)
    return "Positive" if prediction == 1 else "Negative"

# Test the model
test_text = "This is a wonderful example!"
print(f"Sentiment: {predict_sentiment(test_text)}")

Desglose del Código:

Configuración del Pre-entrenamiento (Parte 1):
- Define una clase Dataset personalizada para el manejo de datos de pre-entrenamiento
- Inicializa el modelo BERT con configuración básica
- Crea cargadores de datos para un procesamiento eficiente por lotes
Proceso de Pre-entrenamiento:
- Implementa el bucle de entrenamiento del modelado de lenguaje enmascarado
- Utiliza el optimizador AdamW con tasa de aprendizaje apropiada
- Procesa lotes y actualiza parámetros del modelo
Configuración del Ajuste Fino (Parte 2):
- Convierte el modelo pre-entrenado para clasificación de secuencias
- Prepara el conjunto de datos para análisis de sentimientos
- Implementa el bucle de entrenamiento de ajuste fino
Aplicación del Modelo (Parte 3):
- Crea una función práctica de predicción de sentimientos
- Demuestra cómo usar el modelo ajustado
- Incluye ejemplo de aplicación en el mundo real

Notas Clave de Implementación:

La fase de pre-entrenamiento utiliza modelado de lenguaje enmascarado para aprender patrones generales del lenguaje
El ajuste fino adapta el modelo pre-entrenado para análisis de sentimientos con un entrenamiento adicional mínimo
El ejemplo utiliza un conjunto de datos pequeño para demostración; las aplicaciones reales usarían conjuntos de datos mucho más grandes
Las tasas de aprendizaje se eligen cuidadosamente: más bajas para el ajuste fino (2e-5) que para el pre-entrenamiento (1e-4)

Tokenización con WordPiece

Esta estrategia inteligente de tokenización ofrece varias ventajas clave:

Manejo de vocabulario fuera de registro: BERT puede procesar palabras que no ha encontrado durante el entrenamiento dividiéndolas en subpalabras conocidas
Eficiencia de vocabulario: El modelo puede mantener un vocabulario más pequeño mientras cubre una amplia gama de palabras posibles
Conciencia morfológica: El sistema captura naturalmente prefijos, sufijos y palabras raíz comunes
Capacidades multilingües: Se pueden reconocer partes similares de palabras entre idiomas relacionados
Procesamiento de palabras compuestas: Las palabras complejas y la terminología técnica pueden desglosarse y comprenderse efectivamente

Ejemplo de Código: Tokenización WordPiece

from transformers import BertTokenizer
import pandas as pd

# Initialize the BERT tokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# Example texts with various word types
texts = [
    "immunoelectrophoresis",  # Complex scientific term
    "hyperparameter",         # Technical compound word
    "uncomfortable",          # Word with prefix and suffix
    "pretrained",            # Technical term with prefix
    "3.14159",              # Number
    "AI-powered"            # Hyphenated term
]

# Function to show detailed tokenization
def analyze_tokenization(text):
    # Get tokens and their IDs
    tokens = tokenizer.tokenize(text)
    token_ids = tokenizer.encode(text, add_special_tokens=False)
    
    # Create a detailed breakdown
    return {
        'Original': text,
        'Tokens': tokens,
        'Token IDs': token_ids,
        'Reconstructed': tokenizer.decode(token_ids)
    }

# Analyze each example
results = [analyze_tokenization(text) for text in texts]
df = pd.DataFrame(results)
print(df.to_string())

Desglose del Código:

Inicialización:
- Importamos el tokenizador de BERT desde la biblioteca transformers
- Se utiliza el modelo 'bert-base-uncased', que incluye el vocabulario WordPiece
Selección de Ejemplos:
- Se eligen varios tipos de palabras para demostrar el comportamiento de la tokenización
- Incluye términos científicos, palabras compuestas y caracteres especiales
Función de Análisis:
- El método tokenize() divide las palabras en subpalabras
- encode() convierte los tokens en sus IDs numéricos
- decode() reconstruye el texto original a partir de los IDs

Análisis del Resultado:

# Expected output might look like:
Original: "immunoelectrophoresis"
Tokens: ['imm', '##uno', '##elect', '##ro', '##pho', '##resis']
Token IDs: [2466, 17752, 22047, 2159, 21143, 23875]

Original: "uncomfortable"
Tokens: ['un', '##comfort', '##able']
Token IDs: [2297, 4873, 2137]

Observaciones Clave:

El prefijo '##' indica la continuación de una palabra
Los prefijos comunes (como 'un-') se separan como tokens individuales
Los términos científicos se dividen en subcomponentes significativos
Los números y caracteres especiales reciben un tratamiento especial

Este ejemplo demuestra cómo WordPiece maneja eficazmente varios tipos de palabras mientras mantiene el significado semántico a través de la tokenización inteligente de subpalabras.

5.1.3 Cómo Funciona BERT

Modelado de Lenguaje Enmascarado (MLM):

El proceso de enmascaramiento sigue reglas específicas:

El 80% de los tokens seleccionados se reemplazan con [MASK]
El 10% se reemplazan con palabras aleatorias
El 10% se dejan sin cambios

Esta variedad en el enmascaramiento ayuda a evitar que el modelo dependa demasiado de patrones específicos y asegura un aprendizaje más robusto.

Ejemplo:

Original: "El gato se sentó en la alfombra."
Enmascarado: "El gato se sentó en [MASK] alfombra."
Tarea: El modelo debe predecir "la" usando el contexto de ambas direcciones
Aprendizaje: El modelo aprende relaciones entre palabras y estructuras gramaticales

Ejemplo de Código: Modelado de Lenguaje Enmascarado

import torch
from transformers import BertTokenizer, BertForMaskedLM
import random

# Initialize tokenizer and model
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForMaskedLM.from_pretrained('bert-base-uncased')

def mask_text(text, mask_probability=0.15):
    # Tokenize the input text
    tokens = tokenizer.tokenize(text)
    
    # Decide which tokens to mask
    mask_indices = []
    for i in range(len(tokens)):
        if random.random() < mask_probability:
            mask_indices.append(i)
    
    # Apply masking strategy
    masked_tokens = tokens.copy()
    for idx in mask_indices:
        rand = random.random()
        if rand < 0.8:  # 80% chance to mask
            masked_tokens[idx] = '[MASK]'
        elif rand < 0.9:  # 10% chance to replace with random token
            random_token = tokenizer.convert_ids_to_tokens(
                [random.randint(0, tokenizer.vocab_size)])[0]
            masked_tokens[idx] = random_token
        # 10% chance to keep original token
    
    return tokens, masked_tokens, mask_indices

def predict_masked_tokens(original_tokens, masked_tokens):
    # Convert tokens to input IDs
    inputs = tokenizer.convert_tokens_to_string(masked_tokens)
    inputs = tokenizer(inputs, return_tensors='pt')
    
    # Get model predictions
    with torch.no_grad():
        outputs = model(**inputs)
        predictions = outputs.logits.squeeze()
    
    # Get predictions for masked tokens
    results = []
    for idx in range(len(masked_tokens)):
        if masked_tokens[idx] == '[MASK]':
            predicted_token_id = predictions[idx].argmax().item()
            predicted_token = tokenizer.convert_ids_to_tokens([predicted_token_id])[0]
            results.append({
                'position': idx,
                'original': original_tokens[idx],
                'predicted': predicted_token
            })
    
    return results

# Example usage
text = "The cat sat on the mat while drinking milk."
original_tokens, masked_tokens, mask_indices = mask_text(text)

print("Original:", ' '.join(original_tokens))
print("Masked:", ' '.join(masked_tokens))

predictions = predict_masked_tokens(original_tokens, masked_tokens)
for pred in predictions:
    print(f"Position {pred['position']}: Original '{pred['original']}' → Predicted '{pred['predicted']}'")

Desglose del Código:

Inicialización:
- Carga el modelo BERT preentrenado y el tokenizador específicamente configurado para el modelado de lenguaje enmascarado
- Utiliza 'bert-base-uncased' que tiene un vocabulario de 30,522 tokens
Función de Enmascaramiento (mask_text):
- Implementa la probabilidad de enmascaramiento del 15% de BERT
- Aplica la estrategia de enmascaramiento 80-10-10 (máscara/aleatorio/sin cambios)
- Devuelve tanto las versiones originales como las enmascaradas para comparación
Función de Predicción (predict_masked_tokens):
- Convierte el texto enmascarado en entradas para el modelo
- Utiliza BERT para predecir los tokens más probables para las posiciones enmascaradas
- Devuelve resultados detallados de predicción para análisis

Ejemplo de Salida:

# Sample output might look like:
Original: the cat sat on the mat while drinking milk
Masked: the cat [MASK] on the mat [MASK] drinking milk
Position 2: Original 'sat' → Predicted 'sat'
Position 6: Original 'while' → Predicted 'while'

Notas Clave de Implementación:

El modelo utiliza información contextual de ambas direcciones para hacer predicciones
Las predicciones se basan en distribuciones de probabilidad sobre todo el vocabulario
El proceso de enmascaramiento es aleatorizado para crear ejemplos de entrenamiento diversos
La implementación maneja eficazmente tanto tokens individuales como secuencias más largas

Predicción de la Siguiente Oración (NSP):

Ejemplo:

Oración A: "El gato se sentó en la alfombra."
Oración B: "Era un día soleado."
Resultado: "No Siguiente" (Las oraciones no están relacionadas)

Ejemplo de Código: Predicción de la Siguiente Oración

from transformers import BertTokenizer, BertForNextSentencePrediction
import torch

def check_sentence_pair(sentence_a, sentence_b):
    # Initialize tokenizer and model
    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
    model = BertForNextSentencePrediction.from_pretrained('bert-base-uncased')
    
    # Encode the sentence pair
    encoding = tokenizer(
        sentence_a,
        sentence_b,
        return_tensors='pt',
        max_length=512,
        truncation=True,
        padding='max_length'
    )
    
    # Get model prediction
    with torch.no_grad():
        outputs = model(**encoding)
        logits = outputs.logits
        prob = torch.softmax(logits, dim=1)
        
        # prob[0][0] = probability of "NotNext"
        # prob[0][1] = probability of "IsNext"
        is_next_prob = prob[0][1].item()
    
    return is_next_prob

# Example sentence pairs
sentence_pairs = [
    # Related pair (should be "IsNext")
    ("The cat sat on the mat.", "It was feeling sleepy and comfortable."),
    
    # Unrelated pair (should be "NotNext")
    ("The weather is beautiful today.", "Quantum physics explains particle behavior."),
    
    # Related pair with context
    ("Scientists discovered a new species.", "The findings were published in Nature journal."),
]

# Test each pair
for sent_a, sent_b in sentence_pairs:
    prob = check_sentence_pair(sent_a, sent_b)
    print(f"\nSentence A: {sent_a}")
    print(f"Sentence B: {sent_b}")
    print(f"Probability of B following A: {prob:.2%}")
    print(f"Prediction: {'IsNext' if prob > 0.5 else 'NotNext'}")

Desglose del Código:

Configuración del Modelo:
- Inicializa el tokenizador de BERT y el modelo NSP especializado
- Utiliza 'bert-base-uncased' que está preentrenado en tareas NSP
Procesamiento de Entrada:
- Tokeniza ambas oraciones con tokens especiales ([CLS], [SEP])
- Gestiona el relleno y truncamiento para mantener un tamaño de entrada consistente
- Devuelve tensores adecuados para el procesamiento de BERT
Predicción:
- El modelo genera logits que representan probabilidades para IsNext/NotNext
- Softmax convierte los logits en probabilidades entre 0 y 1
- Devuelve la probabilidad de que las oraciones sean consecutivas

Ejemplo de Salida:

# Expected output:
Sentence A: The cat sat on the mat.
Sentence B: It was feeling sleepy and comfortable.
Probability of B following A: 87.65%
Prediction: IsNext

Sentence A: The weather is beautiful today.
Sentence B: Quantum physics explains particle behavior.
Probability of B following A: 12.34%
Prediction: NotNext

Notas Clave de Implementación:

El modelo considera tanto las relaciones semánticas como contextuales entre oraciones
Las probabilidades más cercanas a 1 indican una mayor probabilidad de que las oraciones sean consecutivas
Se utiliza un umbral de 0.5 para tomar decisiones binarias de EsSiguiente/NoEsSiguiente
El modelo puede manejar varios tipos de relaciones, desde continuaciones directas hasta coherencia temática

5.1.4 Variantes de BERT

RoBERTa (Enfoque de Pre-entrenamiento de BERT Robustamente Optimizado)

Elimina la tarea de Predicción de la Siguiente Oración (NSP) para centrarse únicamente en el Modelado de Lenguaje Enmascarado (MLM):
- La investigación mostró que los beneficios de NSP eran mínimos en comparación con MLM
- Centrarse en MLM permite un entrenamiento más eficiente y una mejor comprensión del lenguaje
Entrena con más datos y tamaños de lote más grandes:
- Utiliza 160GB de texto en comparación con los 16GB de BERT
- Implementa tamaños de lote más grandes (8K tokens) para un entrenamiento más estable
- Entrena durante períodos más largos para lograr una mejor convergencia del modelo
Utiliza enmascaramiento dinámico para proporcionar ejemplos de entrenamiento variados:
- BERT utilizaba enmascaramiento estático aplicado una vez durante el preprocesamiento de datos
- RoBERTa genera nuevos patrones de enmascaramiento cada vez que se alimenta una secuencia al modelo
- Esto evita que el modelo memorice patrones específicos y mejora la generalización

Beneficios Principales:

Mejor rendimiento en puntos de referencia de PLN:
- Supera consistentemente a BERT en los puntos de referencia GLUE, SQuAD y RACE
- Muestra mejoras significativas en tareas de razonamiento complejo
Mayor robustez y precisión en tareas derivadas:
- Proceso de ajuste fino más estable
- Mejores capacidades de transferencia de aprendizaje para tareas de dominio específico
- Mejor rendimiento en escenarios de recursos limitados

Ejemplo de Código: Uso de RoBERTa para Clasificación de Texto

from transformers import RobertaTokenizer, RobertaForSequenceClassification
import torch
from torch.utils.data import Dataset, DataLoader

# Initialize tokenizer and model
tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
model = RobertaForSequenceClassification.from_pretrained('roberta-base', num_labels=2)

class TextDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, 
                                 max_length=max_length, return_tensors='pt')
        self.labels = torch.tensor(labels)

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = self.labels[idx]
        return item

    def __len__(self):
        return len(self.labels)

# Example training data
texts = [
    "This movie was absolutely fantastic!",
    "The plot was confusing and boring.",
    "A masterpiece of modern cinema.",
    "Waste of time and money."
]
labels = [1, 0, 1, 0]  # 1 for positive, 0 for negative

# Create dataset and dataloader
dataset = TextDataset(texts, labels, tokenizer)
loader = DataLoader(dataset, batch_size=2, shuffle=True)

# Training setup
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-5)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)

# Training loop
def train(epochs=3):
    model.train()
    for epoch in range(epochs):
        total_loss = 0
        for batch in loader:
            optimizer.zero_grad()
            
            # Move batch to device
            input_ids = batch['input_ids'].to(device)
            attention_mask = batch['attention_mask'].to(device)
            labels = batch['labels'].to(device)
            
            # Forward pass
            outputs = model(input_ids, attention_mask=attention_mask, 
                          labels=labels)
            loss = outputs.loss
            
            # Backward pass
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
            
        print(f"Epoch {epoch+1}, Average loss: {total_loss/len(loader)}")

# Prediction function
def predict(text):
    model.eval()
    with torch.no_grad():
        inputs = tokenizer(text, return_tensors='pt', 
                         truncation=True, padding=True).to(device)
        outputs = model(**inputs)
        predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
        return predictions.cpu().numpy()

# Train the model
train()

# Example prediction
test_text = "This is an amazing example of natural language processing!"
prediction = predict(test_text)
print(f"Prediction probabilities: Negative: {prediction[0][0]:.3f}, Positive: {prediction[0][1]:.3f}")

Desglose del Código:

Inicialización del Modelo y Tokenizador:
- Utiliza el tokenizador y modelo pre-entrenado de RoBERTa para clasificación de secuencias
- Configura el modelo para clasificación binaria (positivo/negativo)
Implementación del Dataset Personalizado:
- Crea una clase Dataset de PyTorch para el manejo eficiente de datos
- Gestiona la tokenización y conversión a tensores
- Implementa los métodos requeridos de Dataset de PyTorch (__getitem__, __len__)
Pipeline de Entrenamiento:
- Utiliza el optimizador AdamW con una tasa de aprendizaje pequeña para el ajuste fino
- Implementa entrenamiento independiente del dispositivo (CPU/GPU)
- Incluye un bucle completo de entrenamiento con seguimiento de pérdida
Función de Predicción:
- Implementa pipeline de inferencia para entradas de texto individuales
- Devuelve distribuciones de probabilidad para clasificación
- Maneja todo el preprocesamiento necesario automáticamente

Notas Clave de Implementación:

RoBERTa utiliza un enfoque de tokenización diferente al de BERT, optimizado para mejor rendimiento
El modelo maneja automáticamente el relleno y truncamiento para longitudes variables de texto
La implementación incluye gestión adecuada de memoria con puesta a cero de gradientes y procesamiento por lotes
El código demuestra tanto las fases de entrenamiento como de inferencia del modelo

DistilBERT:

El proceso de destilación equilibra cuidadosamente tres objetivos clave de entrenamiento:

Hacer coincidir las probabilidades objetivo suaves producidas por el modelo maestro
Mantener el mismo objetivo de modelado de lenguaje enmascarado que BERT
Preservar la similitud del coseno entre los estados ocultos del maestro y el estudiante
A través de estas optimizaciones, DistilBERT logra mejoras notables en eficiencia:
- 40% de reducción en el tamaño del modelo (de 110M a 66M parámetros)
- 60% más velocidad de procesamiento durante la inferencia
- Mantiene el 97% de las capacidades de comprensión del lenguaje de BERT

Beneficios Principales:

Ideal para implementación en entornos con recursos limitados:
- Adecuado para dispositivos móviles y computación en el borde
- La huella de memoria reducida permite más opciones de implementación
- Menores requisitos computacionales significan menor consumo de energía
Inferencia más rápida con pérdida mínima de rendimiento:
- Permite aplicaciones en tiempo real y mayor rendimiento
- Mantiene alta precisión en la mayoría de tareas de PLN
- Más rentable para implementaciones a gran escala

Ejemplo de Código: Uso de DistilBERT para Clasificación de Texto

from transformers import DistilBertTokenizer, DistilBertForSequenceClassification
import torch
from torch.utils.data import Dataset, DataLoader

# Initialize tokenizer and model
tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')
model = DistilBertForSequenceClassification.from_pretrained('distilbert-base-uncased', num_labels=2)

class TextClassificationDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, 
                                 max_length=max_length, return_tensors='pt')
        self.labels = torch.tensor(labels)

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = self.labels[idx]
        return item

    def __len__(self):
        return len(self.labels)

# Example data
texts = [
    "This product exceeded my expectations!",
    "Very disappointed with the quality.",
    "Great value for money, highly recommend.",
    "Customer service was terrible."
]
labels = [1, 0, 1, 0]  # 1: Positive, 0: Negative

# Create dataset and dataloader
dataset = TextClassificationDataset(texts, labels, tokenizer)
loader = DataLoader(dataset, batch_size=2, shuffle=True)

# Training configuration
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5)
num_epochs = 3

# Training loop
def train_model():
    model.train()
    for epoch in range(num_epochs):
        total_loss = 0
        for batch in loader:
            optimizer.zero_grad()
            
            # Move batch to device
            input_ids = batch['input_ids'].to(device)
            attention_mask = batch['attention_mask'].to(device)
            labels = batch['labels'].to(device)
            
            # Forward pass
            outputs = model(input_ids, attention_mask=attention_mask, 
                          labels=labels)
            loss = outputs.loss
            
            # Backward pass and optimization
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
        
        avg_loss = total_loss / len(loader)
        print(f"Epoch {epoch + 1}/{num_epochs}, Average Loss: {avg_loss:.4f}")

# Inference function
def predict_sentiment(text):
    model.eval()
    with torch.no_grad():
        inputs = tokenizer(text, return_tensors='pt', 
                         truncation=True, padding=True).to(device)
        outputs = model(**inputs)
        probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
        return probs.cpu().numpy()[0]

# Train the model
train_model()

# Example prediction
test_text = "The customer support team was very helpful!"
prediction = predict_sentiment(test_text)
print(f"\nTest text: {test_text}")
print(f"Sentiment prediction: Negative: {prediction[0]:.3f}, Positive: {prediction[1]:.3f}")

Desglose del Código:

Configuración del Modelo y Tokenizador:
- Inicializa el tokenizador y modelo de clasificación de DistilBERT
- Utiliza el modelo pre-entrenado 'distilbert-base-uncased'
- Configura para clasificación binaria (sentimiento positivo/negativo)
Implementación del Dataset Personalizado:
- Crea una clase Dataset de PyTorch para el manejo eficiente de datos
- Gestiona la tokenización y conversión a tensores
- Implementa los métodos requeridos de Dataset para compatibilidad con PyTorch
Pipeline de Entrenamiento:
- Utiliza el optimizador AdamW con una tasa de aprendizaje de 5e-5
- Implementa entrenamiento independiente del dispositivo (CPU/GPU)
- Incluye seguimiento de pérdida y reporte de progreso por época
Implementación de Inferencia:
- Proporciona una función dedicada de predicción para entradas de texto individuales
- Devuelve distribuciones de probabilidad para clasificación binaria
- Maneja automáticamente todos los pasos necesarios de preprocesamiento

Notas Clave de Implementación:

El código demuestra la eficiencia de DistilBERT mientras mantiene el rendimiento similar a BERT
La implementación incluye gestión adecuada de memoria y procesamiento por lotes
El modelo maneja automáticamente el preprocesamiento y tokenización del texto
Muestra tanto las fases de entrenamiento como de inferencia con ejemplos prácticos

Ejemplo Práctico: Uso de BERT y sus Variantes

Usemos Hugging Face Transformers para cargar y ajustar BERT, RoBERTa y DistilBERT para una tarea de clasificación de texto.

Ejemplo de Código: Ajuste Fino de BERT para Análisis de Sentimiento

from transformers import BertTokenizer, BertForSequenceClassification, Trainer, TrainingArguments
from torch.utils.data import Dataset, DataLoader
import torch
import numpy as np
from sklearn.metrics import accuracy_score, precision_recall_fscore_support

# Custom Dataset Class
class SentimentDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, 
                                 max_length=max_length, return_tensors="pt")
        self.labels = torch.tensor(labels)

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = self.labels[idx]
        return item

# Metrics computation function
def compute_metrics(pred):
    labels = pred.label_ids
    preds = pred.predictions.argmax(-1)
    precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='binary')
    acc = accuracy_score(labels, preds)
    return {
        'accuracy': acc,
        'f1': f1,
        'precision': precision,
        'recall': recall
    }

# Load pre-trained BERT and tokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
model = BertForSequenceClassification.from_pretrained(
    "bert-base-uncased",
    num_labels=2,
    output_attentions=True
)

# Example data
texts = [
    "The movie was fantastic!",
    "I did not enjoy the food.",
    "This is the best book I've ever read!",
    "The service was terrible and slow.",
    "Absolutely loved the experience!"
]
labels = [1, 0, 1, 0, 1]  # 1 = Positive, 0 = Negative

# Create datasets
train_dataset = SentimentDataset(texts, labels, tokenizer)

# Define training arguments
training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
    logging_dir='./logs',
    logging_steps=10,
    load_best_model_at_end=True,
    metric_for_best_model='f1',
    save_strategy="epoch"
)

# Initialize trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    compute_metrics=compute_metrics
)

# Train the model
trainer.train()

# Example inference
def predict_sentiment(text):
    # Prepare input
    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
    
    # Get prediction
    with torch.no_grad():
        outputs = model(**inputs)
        probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
        prediction = torch.argmax(probabilities, dim=-1)
    
    return {
        "text": text,
        "sentiment": "Positive" if prediction == 1 else "Negative",
        "confidence": float(probabilities[0][prediction])
    }

# Test predictions
test_texts = [
    "I would highly recommend this product!",
    "This was a complete waste of money."
]

for text in test_texts:
    result = predict_sentiment(text)
    print(f"\nText: {result['text']}")
    print(f"Sentiment: {result['sentiment']}")
    print(f"Confidence: {result['confidence']:.4f}")

Desglose y Explicación del Código:

Implementación del Dataset Personalizado:
- Crea una clase Dataset personalizada de PyTorch (SentimentDataset)
- Maneja la tokenización y conversión de datos de texto a tensores
- Implementa los métodos requeridos de Dataset (__len__, __getitem__)
Configuración y Preparación del Modelo:
- Inicializa el tokenizador y modelo de clasificación BERT
- Configura para clasificación binaria de sentimientos
- Habilita las salidas de atención para análisis potencial
Configuración del Entrenamiento:
- Define argumentos completos de entrenamiento
- Implementa configuraciones de tasa de aprendizaje y tamaño de lote
- Incluye estrategias de registro y guardado del modelo
Métricas y Evaluación:
- Implementa la función compute_metrics para seguimiento del rendimiento
- Calcula precisión, puntuación F1, precisión y exhaustividad
- Permite la evaluación del modelo durante el entrenamiento
Pipeline de Inferencia:
- Crea una función dedicada de predicción
- Maneja entradas de texto individuales con preprocesamiento adecuado
- Devuelve resultados detallados de predicción con puntuaciones de confianza

5.1.5 Casos de Uso Clave de BERT y sus Variantes

Clasificación de Texto:

Respuesta a Preguntas:

La destreza del modelo en respuesta a preguntas proviene de su capacidad para:

Procesar relaciones semánticas entre palabras y frases a través de largas distancias en el texto
Comprender diversos tipos de preguntas, desde consultas factuales hasta preguntas de razonamiento más abstracto
Considerar múltiples niveles de contexto simultáneamente, desde la comprensión a nivel de palabra hasta nivel de oración
Generar respuestas contextualmente apropiadas sintetizando información de diferentes partes del pasaje

Ejemplo de Código: Respuesta a Preguntas con BERT

from transformers import AutoTokenizer, AutoModelForQuestionAnswering
import torch

def setup_qa_model():
    # Initialize tokenizer and model
    tokenizer = AutoTokenizer.from_pretrained("bert-large-uncased-whole-word-masking-finetuned-squad")
    model = AutoModelForQuestionAnswering.from_pretrained("bert-large-uncased-whole-word-masking-finetuned-squad")
    return tokenizer, model

def answer_question(question, context, tokenizer, model):
    # Tokenize input text
    inputs = tokenizer(
        question,
        context,
        add_special_tokens=True,
        return_tensors="pt",
        max_length=512,
        truncation=True,
        padding='max_length'
    )
    
    # Get model predictions
    with torch.no_grad():
        outputs = model(**inputs)
        answer_start = outputs.start_logits.argmax()
        answer_end = outputs.end_logits.argmax()
    
    # Convert token positions to text
    tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
    answer = tokenizer.convert_tokens_to_string(tokens[answer_start:answer_end + 1])
    
    # Calculate confidence scores
    start_scores = torch.softmax(outputs.start_logits, dim=1)[0]
    end_scores = torch.softmax(outputs.end_logits, dim=1)[0]
    confidence = float((start_scores[answer_start] * end_scores[answer_end]).item())
    
    return {
        "answer": answer,
        "confidence": confidence,
        "start": answer_start,
        "end": answer_end
    }

# Example usage
tokenizer, model = setup_qa_model()

context = """
The Transformer architecture was introduced in the paper 'Attention Is All You Need' 
by Vaswani et al. in 2017. BERT, which stands for Bidirectional Encoder Representations 
from Transformers, was developed by researchers at Google AI Language in 2018. It 
revolutionized NLP by introducing bidirectional training and achieving state-of-the-art 
results on various language tasks.
"""

questions = [
    "When was the Transformer architecture introduced?",
    "Who developed BERT?",
    "What does BERT stand for?"
]

for question in questions:
    result = answer_question(question, context, tokenizer, model)
    print(f"\nQuestion: {question}")
    print(f"Answer: {result['answer']}")
    print(f"Confidence: {result['confidence']:.4f}")

Desglose del código:

Configuración e Inicialización del Modelo:
- Utiliza un modelo BERT pre-entrenado específicamente ajustado para responder preguntas en el conjunto de datos SQuAD
- Inicializa tanto el tokenizador como el modelo desde la biblioteca transformers de Hugging Face
Implementación de la Función de Respuesta a Preguntas:
- Maneja el preprocesamiento de entrada con tokenización adecuada
- Gestiona la longitud máxima de secuencia y el truncamiento
- Implementa procesamiento por lotes eficiente con PyTorch
Proceso de Extracción de Respuestas:
- Identifica las posiciones de inicio y fin de la respuesta en el texto
- Convierte las posiciones de tokens a texto legible
- Calcula puntuaciones de confianza para las predicciones
Procesamiento de Resultados:
- Devuelve una salida estructurada con la respuesta, puntuación de confianza e información de posición
- Maneja casos extremos y posibles errores en la extracción de respuestas
- Proporciona métricas de confianza significativas para la fiabilidad de las respuestas

Reconocimiento de Entidades Nombradas (NER)

Nombres de personas, incluyendo variaciones y apodos
Expresiones temporales como fechas, horas y duraciones
Ubicaciones geográficas a diferentes escalas (ciudades, países, puntos de referencia)
Nombres de organizaciones, incluyendo empresas, instituciones y organismos gubernamentales
Nombres de productos y marcas en diferentes industrias
Valores monetarios en varias monedas y formatos
Entidades personalizadas específicas para dominios o industrias particulares

Esta sofisticada funcionalidad de reconocimiento de entidades sirve como piedra angular para numerosas aplicaciones prácticas:

Revisión de Documentos Legales: Identificación automática de partes, fechas, montos monetarios y entidades legales
Análisis de Registros Médicos: Extracción de información del paciente, condiciones médicas, medicamentos y fechas de tratamiento
Inteligencia Empresarial: Seguimiento de menciones de empresas, referencias de productos y tendencias del mercado
Investigación y Academia: Identificación de citas, nombres de autores y afiliaciones institucionales
Análisis Financiero: Detección de nombres de empresas, valores monetarios y detalles de transacciones
Noticias y Medios: Categorización de personas, organizaciones y ubicaciones en artículos de noticias

Ejemplo de Código: Reconocimiento de Entidades Nombradas con BERT

from transformers import AutoTokenizer, AutoModelForTokenClassification
import torch
from torch.nn import functional as F

def setup_ner_model():
    # Initialize tokenizer and model for NER
    tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")
    model = AutoModelForTokenClassification.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")
    return tokenizer, model

def perform_ner(text, tokenizer, model):
    # Tokenize input text
    inputs = tokenizer(
        text,
        add_special_tokens=True,
        return_tensors="pt",
        truncation=True,
        max_length=512
    )
    
    # Get predictions
    with torch.no_grad():
        outputs = model(**inputs)
        predictions = F.softmax(outputs.logits, dim=-1)
        predictions = torch.argmax(predictions, dim=-1)
    
    # Process tokens and predictions
    tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
    label_list = model.config.id2label
    
    entities = []
    current_entity = None
    
    for idx, (token, pred) in enumerate(zip(tokens, predictions[0])):
        label = label_list[pred.item()]
        
        # Skip special tokens
        if token in [tokenizer.sep_token, tokenizer.cls_token, tokenizer.pad_token]:
            continue
            
        # Handle B- (beginning) and I- (inside) tags
        if label.startswith("B-"):
            if current_entity:
                entities.append(current_entity)
            current_entity = {
                "entity": token.replace("##", ""),
                "type": label[2:],
                "start": idx
            }
        elif label.startswith("I-") and current_entity:
            current_entity["entity"] += token.replace("##", "")
        elif label == "O":  # Outside any entity
            if current_entity:
                entities.append(current_entity)
                current_entity = None
    
    if current_entity:
        entities.append(current_entity)
    
    return entities

# Example usage
def demonstrate_ner():
    tokenizer, model = setup_ner_model()
    
    sample_text = """
    Apple Inc. CEO Tim Cook announced a new partnership with Microsoft 
    Corporation in New York City last Friday. The deal, worth $5 billion, 
    will help both companies expand their presence in the artificial 
    intelligence market.
    """
    
    entities = perform_ner(sample_text, tokenizer, model)
    
    # Print results
    for entity in entities:
        print(f"Entity: {entity['entity']}")
        print(f"Type: {entity['type']}")
        print("---")

Desglose y Explicación del Código:

Inicialización y Configuración del Modelo:
- Utiliza un modelo BERT pre-entrenado específicamente ajustado para tareas de NER
- Aprovecha la biblioteca transformers de Hugging Face para la configuración del modelo y tokenizador
- Configura el modelo para la clasificación de tokens con etiquetas de entidades
Función de Procesamiento NER:
- Implementa tokenización eficiente con manejo adecuado de tokens especiales
- Gestiona limitaciones de longitud de secuencia y truncamiento
- Utiliza el contexto no_grad de PyTorch para inferencia eficiente
Reconocimiento y Procesamiento de Entidades:
- Maneja el esquema de etiquetado BIO (Principio, Dentro, Fuera)
- Procesa tokens parciales y reconstruye entidades completas
- Mantiene con precisión los límites y tipos de entidades
Procesamiento de Salida:
- Crea una salida estructurada con texto de entidad, tipo e información de posición
- Maneja casos extremos y reconstrucción de tokens
- Proporciona resultados limpios y organizados de extracción de entidades

Tareas con Recursos Limitados:

Los logros clave de DistilBERT son impresionantes:

Retención de Rendimiento: Preserva aproximadamente el 97% de las capacidades de comprensión del lenguaje de BERT, asegurando resultados de alta calidad
Optimización de Tamaño: El modelo logra una reducción del 40% en tamaño comparado con BERT, requiriendo significativamente menos espacio de almacenamiento
Mejora de Velocidad: La velocidad de procesamiento aumenta en un 60%, permitiendo tiempos de inferencia más rápidos y mejor capacidad de respuesta

Estas mejoras hacen que DistilBERT sea particularmente valioso para varias aplicaciones del mundo real:

Aplicaciones Móviles: Permite características sofisticadas de PLN en smartphones y tablets sin consumo excesivo de batería o requisitos de almacenamiento
Computación de Borde: Permite el procesamiento local en dispositivos IoT y servidores edge, reduciendo la necesidad de conectividad en la nube
Sistemas en Tiempo Real: Admite aplicaciones que requieren respuestas inmediatas, como traducción en vivo o análisis de mensajes instantáneos
Entornos con Recursos Limitados: Hace el PLN avanzado accesible en entornos con poder computacional o memoria limitados

Ejemplo de Código: Tareas con Recursos Limitados usando DistilBERT

from transformers import DistilBertTokenizer, DistilBertForSequenceClassification
import torch
from torch.nn import functional as F

def setup_distilbert():
    # Initialize tokenizer and model
    tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')
    model = DistilBertForSequenceClassification.from_pretrained(
        'distilbert-base-uncased',
        num_labels=2  # Binary classification
    )
    return tokenizer, model

def optimize_model_for_inference(model):
    # Convert to inference mode
    model.eval()
    # Quantize model to reduce memory footprint
    model = torch.quantization.quantize_dynamic(
        model, {torch.nn.Linear}, dtype=torch.qint8
    )
    return model

def process_text(text, tokenizer, model, max_length=128):
    # Tokenize with truncation
    inputs = tokenizer(
        text,
        truncation=True,
        max_length=max_length,
        padding='max_length',
        return_tensors='pt'
    )
    
    # Efficient inference
    with torch.no_grad():
        outputs = model(**inputs)
        predictions = F.softmax(outputs.logits, dim=-1)
    
    return predictions

def batch_process_texts(texts, tokenizer, model, batch_size=16):
    results = []
    
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        batch_predictions = process_text(batch, tokenizer, model)
        results.extend(batch_predictions.tolist())
    
    return results

# Example usage
def demonstrate_resource_constrained_classification():
    tokenizer, model = setup_distilbert()
    model = optimize_model_for_inference(model)
    
    sample_texts = [
        "This product works great and I'm very satisfied!",
        "The quality is terrible, would not recommend.",
        "Decent product for the price point."
    ]
    
    predictions = batch_process_texts(sample_texts, tokenizer, model)
    
    for text, pred in zip(sample_texts, predictions):
        sentiment = "Positive" if pred[1] > 0.5 else "Negative"
        confidence = max(pred)
        print(f"Text: {text}")
        print(f"Sentiment: {sentiment} (Confidence: {confidence:.2f})")
        print("---")

Desglose del Código:

Configuración y Optimización del Modelo:
- Inicializa DistilBERT con una configuración mínima para clasificación de secuencias
- Implementa la cuantización del modelo para reducir el uso de memoria
- Configura el modelo para un modo de inferencia eficiente
Función de Procesamiento de Texto:
- Implementa tokenización eficiente con restricciones de longitud
- Utiliza procesamiento por lotes dinámico para un uso óptimo de recursos
- Gestiona la memoria eficientemente con el contexto no_grad
Técnicas de Optimización de Recursos:
- Emplea cuantización del modelo para reducir la huella de memoria
- Implementa procesamiento por lotes para maximizar el rendimiento
- Utiliza estrategias de truncamiento y relleno para gestionar longitudes de secuencia
Consideraciones de Rendimiento:
- Equilibra el tamaño del lote con las restricciones de memoria
- Implementa agregación eficiente de predicciones
- Proporciona puntuaciones de confianza para la fiabilidad de las predicciones

5.1.6 Puntos Clave

BERT (Representaciones Codificadas Bidireccionales de Transformers) trajo un cambio fundamental al PLN al introducir incrustaciones bidireccionales conscientes del contexto. A diferencia de los modelos anteriores que procesaban texto en una dirección, BERT analiza las palabras en relación con todas las demás palabras en una oración simultáneamente. Esta innovación, combinada con su enfoque de pre-entrenamiento/ajuste fino, permite que el modelo desarrolle una comprensión profunda del contexto y matices del lenguaje. Durante el pre-entrenamiento, BERT aprende de cantidades masivas de texto prediciendo palabras enmascaradas y comprendiendo relaciones entre oraciones. Luego, mediante el ajuste fino, puede adaptarse para tareas específicas mientras mantiene su comprensión fundamental del lenguaje.
El éxito de BERT inspiró varias variantes importantes. RoBERTa (Enfoque BERT Robustamente Optimizado) mejoró la arquitectura original modificando el proceso de pre-entrenamiento - usando lotes más grandes de datos, entrenando durante períodos más largos y eliminando la tarea de predicción de la siguiente oración. Estas optimizaciones condujeron a mejoras significativas en el rendimiento. Mientras tanto, DistilBERT abordó los desafíos prácticos de implementación creando una versión más ligera que mantiene la mayoría de las capacidades de BERT mientras usa menos recursos computacionales. Esto se logró mediante la destilación del conocimiento, donde un modelo más pequeño aprende a replicar el comportamiento del modelo más grande, haciendo que las potentes capacidades de PLN sean accesibles para organizaciones con recursos computacionales limitados.
El impacto práctico de estos modelos ha sido notable. En clasificación de texto, logran alta precisión en la categorización de documentos, correos electrónicos y publicaciones en redes sociales. Para respuesta a preguntas, pueden entender consultas complejas y extraer información relevante de textos largos. En análisis de sentimientos, sobresalen en detectar sutiles matices emocionales en el texto. Su versatilidad se extiende a tareas como reconocimiento de entidades nombradas, resumen de texto y traducción de idiomas, donde consistentemente superan los enfoques tradicionales. Esta combinación de alto rendimiento y eficiencia los ha convertido en la base de numerosas aplicaciones del mundo real en industrias que van desde la atención médica hasta el servicio al cliente.

5.1 BERT y sus Variantes (RoBERTa, DistilBERT)

5.1.1 Introducción a BERT

Respuesta a preguntas: Comprensión de consultas complejas y búsqueda de respuestas relevantes en el texto
Análisis de sentimientos: Determinación precisa del tono emocional y la opinión en el texto
Reconocimiento de entidades nombradas: Identificación y clasificación de información clave como nombres, ubicaciones y organizaciones en el texto

5.1.2 Innovaciones Fundamentales de BERT

Contexto Bidireccional

Por ejemplo, considere la oración "La orilla del río está lodosa". En este caso, el procesamiento bidireccional de BERT le permite:

Mirar hacia adelante para ver "lodosa" y "río"
Mirar hacia atrás para entender el contexto de "La"
Combinar estas pistas contextuales para determinar con precisión que "orilla" se refiere a la ribera del río y no a una institución financiera

Ejemplo de Código: Demostrando el Contexto Bidireccional de BERT

from transformers import BertTokenizer, BertForMaskedLM
import torch

# Initialize tokenizer and model
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForMaskedLM.from_pretrained('bert-base-uncased')

# Example sentence with masked token
text = "The [MASK] bank is near the river."

# Tokenize input
inputs = tokenizer(text, return_tensors="pt")

# Get the position of the masked token
mask_token_index = torch.where(inputs["input_ids"] == tokenizer.mask_token_id)[1]

# Get model predictions
with torch.no_grad():
    outputs = model(**inputs)
    predictions = outputs.logits

# Get the predicted token
predicted_token_id = predictions[0, mask_token_index].argmax(axis=-1)
predicted_token = tokenizer.decode(predicted_token_id)

print(f"Original text: {text}")
print(f"Predicted word: {predicted_token}")

# Try another context
text_2 = "I need to deposit money at the [MASK] bank."
inputs_2 = tokenizer(text_2, return_tensors="pt")
mask_token_index_2 = torch.where(inputs_2["input_ids"] == tokenizer.mask_token_id)[1]

with torch.no_grad():
    outputs_2 = model(**inputs_2)
    predictions_2 = outputs_2.logits

predicted_token_id_2 = predictions_2[0, mask_token_index_2].argmax(axis=-1)
predicted_token_2 = tokenizer.decode(predicted_token_id_2)

print(f"\nOriginal text: {text_2}")
print(f"Predicted word: {predicted_token_2}")

Desglose del Código:

Inicialización del Modelo y Tokenizador:

Cargamos el tokenizador de BERT y el modelo de lenguaje enmascarado
Se utiliza la versión 'bert-base-uncased', que tiene un vocabulario de tokens en minúsculas

Procesamiento de Entrada:

Creamos dos oraciones de ejemplo con tokens [MASK]
El tokenizador convierte el texto en representaciones numéricas que BERT puede procesar

Análisis de Contexto Bidireccional:

BERT analiza el contexto tanto a la izquierda como a la derecha del token enmascarado
En el primer ejemplo, "river" influye en la predicción
En el segundo ejemplo, "deposit money" proporciona un contexto diferente

Generación de Predicciones:

El modelo genera distribuciones de probabilidad para todos los tokens posibles
Seleccionamos el token con la probabilidad más alta como predicción

Salida Esperada:

# Output might look like:
Original text: The [MASK] bank is near the river.
Predicted word: river

Original text: I need to deposit money at the [MASK] bank.
Predicted word: local

Paradigma de Pre-entrenamiento y Ajuste Fino

Vocabulario y patrones de uso de palabras
Estructuras y relaciones gramaticales
Significados contextuales de las palabras
Frases y expresiones comunes
Conocimiento básico del mundo incorporado en el lenguaje

Análisis de sentimientos
Respuesta a preguntas
Clasificación de texto
Reconocimiento de entidades nombradas
Resumen de documentos

El proceso costoso y prolongado de pre-entrenamiento solo necesita realizarse una vez
El ajuste fino requiere relativamente pocos datos específicos de la tarea
El proceso puede completarse rápidamente con recursos computacionales mínimos
El modelo resultante mantiene un alto rendimiento al combinar la comprensión amplia del lenguaje con la optimización específica de la tarea

Ejemplo de Código: Pre-entrenamiento y Ajuste Fino de BERT

# 1. Pre-training setup
from transformers import BertConfig, BertForMaskedLM, BertTokenizer
import torch
from torch.utils.data import Dataset, DataLoader

# Custom dataset for pre-training
class PretrainingDataset(Dataset):
    def __init__(self, texts, tokenizer, max_length=512):
        self.encodings = tokenizer(texts, truncation=True, padding='max_length',
                                 max_length=max_length, return_tensors='pt')
        
    def __getitem__(self, idx):
        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
        return item
    
    def __len__(self):
        return len(self.encodings.input_ids)

# Initialize model and tokenizer
config = BertConfig(vocab_size=30522, hidden_size=768)
model = BertForMaskedLM(config)
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# Example pre-training data
pretrain_texts = [
    "The quick brown fox jumps over the lazy dog.",
    "Machine learning is transforming the world of technology."
]

# Create pre-training dataset
pretrain_dataset = PretrainingDataset(pretrain_texts, tokenizer)
pretrain_loader = DataLoader(pretrain_dataset, batch_size=2, shuffle=True)

# Pre-training loop
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)

for epoch in range(3):
    for batch in pretrain_loader:
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

# 2. Fine-tuning for sentiment analysis
from transformers import BertForSequenceClassification

# Convert pre-trained model for classification
model = BertForSequenceClassification.from_pretrained('bert-base-uncased',
                                                     num_labels=2)

# Example fine-tuning data
texts = ["This movie is fantastic!", "The food was terrible."]
labels = torch.tensor([1, 0])  # 1 for positive, 0 for negative

# Prepare fine-tuning data
encodings = tokenizer(texts, truncation=True, padding=True, return_tensors='pt')
dataset = [(encodings, labels)]

# Fine-tuning loop
optimizer = torch.optim.AdamW(model.parameters(), lr=2e-5)

for epoch in range(3):
    for batch_encodings, batch_labels in dataset:
        outputs = model(**batch_encodings, labels=batch_labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

# 3. Using the fine-tuned model
def predict_sentiment(text):
    inputs = tokenizer(text, return_tensors='pt', truncation=True, padding=True)
    outputs = model(**inputs)
    prediction = torch.argmax(outputs.logits, dim=1)
    return "Positive" if prediction == 1 else "Negative"

# Test the model
test_text = "This is a wonderful example!"
print(f"Sentiment: {predict_sentiment(test_text)}")

Desglose del Código:

Configuración del Pre-entrenamiento (Parte 1):
- Define una clase Dataset personalizada para el manejo de datos de pre-entrenamiento
- Inicializa el modelo BERT con configuración básica
- Crea cargadores de datos para un procesamiento eficiente por lotes
Proceso de Pre-entrenamiento:
- Implementa el bucle de entrenamiento del modelado de lenguaje enmascarado
- Utiliza el optimizador AdamW con tasa de aprendizaje apropiada
- Procesa lotes y actualiza parámetros del modelo
Configuración del Ajuste Fino (Parte 2):
- Convierte el modelo pre-entrenado para clasificación de secuencias
- Prepara el conjunto de datos para análisis de sentimientos
- Implementa el bucle de entrenamiento de ajuste fino
Aplicación del Modelo (Parte 3):
- Crea una función práctica de predicción de sentimientos
- Demuestra cómo usar el modelo ajustado
- Incluye ejemplo de aplicación en el mundo real

Notas Clave de Implementación:

La fase de pre-entrenamiento utiliza modelado de lenguaje enmascarado para aprender patrones generales del lenguaje
El ajuste fino adapta el modelo pre-entrenado para análisis de sentimientos con un entrenamiento adicional mínimo
El ejemplo utiliza un conjunto de datos pequeño para demostración; las aplicaciones reales usarían conjuntos de datos mucho más grandes
Las tasas de aprendizaje se eligen cuidadosamente: más bajas para el ajuste fino (2e-5) que para el pre-entrenamiento (1e-4)

Tokenización con WordPiece

Esta estrategia inteligente de tokenización ofrece varias ventajas clave:

Manejo de vocabulario fuera de registro: BERT puede procesar palabras que no ha encontrado durante el entrenamiento dividiéndolas en subpalabras conocidas
Eficiencia de vocabulario: El modelo puede mantener un vocabulario más pequeño mientras cubre una amplia gama de palabras posibles
Conciencia morfológica: El sistema captura naturalmente prefijos, sufijos y palabras raíz comunes
Capacidades multilingües: Se pueden reconocer partes similares de palabras entre idiomas relacionados
Procesamiento de palabras compuestas: Las palabras complejas y la terminología técnica pueden desglosarse y comprenderse efectivamente

Ejemplo de Código: Tokenización WordPiece

from transformers import BertTokenizer
import pandas as pd

# Initialize the BERT tokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# Example texts with various word types
texts = [
    "immunoelectrophoresis",  # Complex scientific term
    "hyperparameter",         # Technical compound word
    "uncomfortable",          # Word with prefix and suffix
    "pretrained",            # Technical term with prefix
    "3.14159",              # Number
    "AI-powered"            # Hyphenated term
]

# Function to show detailed tokenization
def analyze_tokenization(text):
    # Get tokens and their IDs
    tokens = tokenizer.tokenize(text)
    token_ids = tokenizer.encode(text, add_special_tokens=False)
    
    # Create a detailed breakdown
    return {
        'Original': text,
        'Tokens': tokens,
        'Token IDs': token_ids,
        'Reconstructed': tokenizer.decode(token_ids)
    }

# Analyze each example
results = [analyze_tokenization(text) for text in texts]
df = pd.DataFrame(results)
print(df.to_string())

Desglose del Código:

Inicialización:
- Importamos el tokenizador de BERT desde la biblioteca transformers
- Se utiliza el modelo 'bert-base-uncased', que incluye el vocabulario WordPiece
Selección de Ejemplos:
- Se eligen varios tipos de palabras para demostrar el comportamiento de la tokenización
- Incluye términos científicos, palabras compuestas y caracteres especiales
Función de Análisis:
- El método tokenize() divide las palabras en subpalabras
- encode() convierte los tokens en sus IDs numéricos
- decode() reconstruye el texto original a partir de los IDs

Análisis del Resultado:

# Expected output might look like:
Original: "immunoelectrophoresis"
Tokens: ['imm', '##uno', '##elect', '##ro', '##pho', '##resis']
Token IDs: [2466, 17752, 22047, 2159, 21143, 23875]

Original: "uncomfortable"
Tokens: ['un', '##comfort', '##able']
Token IDs: [2297, 4873, 2137]

Observaciones Clave:

El prefijo '##' indica la continuación de una palabra
Los prefijos comunes (como 'un-') se separan como tokens individuales
Los términos científicos se dividen en subcomponentes significativos
Los números y caracteres especiales reciben un tratamiento especial

Este ejemplo demuestra cómo WordPiece maneja eficazmente varios tipos de palabras mientras mantiene el significado semántico a través de la tokenización inteligente de subpalabras.

5.1.3 Cómo Funciona BERT

Modelado de Lenguaje Enmascarado (MLM):

El proceso de enmascaramiento sigue reglas específicas:

El 80% de los tokens seleccionados se reemplazan con [MASK]
El 10% se reemplazan con palabras aleatorias
El 10% se dejan sin cambios

Esta variedad en el enmascaramiento ayuda a evitar que el modelo dependa demasiado de patrones específicos y asegura un aprendizaje más robusto.

Ejemplo:

Original: "El gato se sentó en la alfombra."
Enmascarado: "El gato se sentó en [MASK] alfombra."
Tarea: El modelo debe predecir "la" usando el contexto de ambas direcciones
Aprendizaje: El modelo aprende relaciones entre palabras y estructuras gramaticales

Ejemplo de Código: Modelado de Lenguaje Enmascarado

import torch
from transformers import BertTokenizer, BertForMaskedLM
import random

# Initialize tokenizer and model
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForMaskedLM.from_pretrained('bert-base-uncased')

def mask_text(text, mask_probability=0.15):
    # Tokenize the input text
    tokens = tokenizer.tokenize(text)
    
    # Decide which tokens to mask
    mask_indices = []
    for i in range(len(tokens)):
        if random.random() < mask_probability:
            mask_indices.append(i)
    
    # Apply masking strategy
    masked_tokens = tokens.copy()
    for idx in mask_indices:
        rand = random.random()
        if rand < 0.8:  # 80% chance to mask
            masked_tokens[idx] = '[MASK]'
        elif rand < 0.9:  # 10% chance to replace with random token
            random_token = tokenizer.convert_ids_to_tokens(
                [random.randint(0, tokenizer.vocab_size)])[0]
            masked_tokens[idx] = random_token
        # 10% chance to keep original token
    
    return tokens, masked_tokens, mask_indices

def predict_masked_tokens(original_tokens, masked_tokens):
    # Convert tokens to input IDs
    inputs = tokenizer.convert_tokens_to_string(masked_tokens)
    inputs = tokenizer(inputs, return_tensors='pt')
    
    # Get model predictions
    with torch.no_grad():
        outputs = model(**inputs)
        predictions = outputs.logits.squeeze()
    
    # Get predictions for masked tokens
    results = []
    for idx in range(len(masked_tokens)):
        if masked_tokens[idx] == '[MASK]':
            predicted_token_id = predictions[idx].argmax().item()
            predicted_token = tokenizer.convert_ids_to_tokens([predicted_token_id])[0]
            results.append({
                'position': idx,
                'original': original_tokens[idx],
                'predicted': predicted_token
            })
    
    return results

# Example usage
text = "The cat sat on the mat while drinking milk."
original_tokens, masked_tokens, mask_indices = mask_text(text)

print("Original:", ' '.join(original_tokens))
print("Masked:", ' '.join(masked_tokens))

predictions = predict_masked_tokens(original_tokens, masked_tokens)
for pred in predictions:
    print(f"Position {pred['position']}: Original '{pred['original']}' → Predicted '{pred['predicted']}'")

Desglose del Código:

Inicialización:
- Carga el modelo BERT preentrenado y el tokenizador específicamente configurado para el modelado de lenguaje enmascarado
- Utiliza 'bert-base-uncased' que tiene un vocabulario de 30,522 tokens
Función de Enmascaramiento (mask_text):
- Implementa la probabilidad de enmascaramiento del 15% de BERT
- Aplica la estrategia de enmascaramiento 80-10-10 (máscara/aleatorio/sin cambios)
- Devuelve tanto las versiones originales como las enmascaradas para comparación
Función de Predicción (predict_masked_tokens):
- Convierte el texto enmascarado en entradas para el modelo
- Utiliza BERT para predecir los tokens más probables para las posiciones enmascaradas
- Devuelve resultados detallados de predicción para análisis

Ejemplo de Salida:

# Sample output might look like:
Original: the cat sat on the mat while drinking milk
Masked: the cat [MASK] on the mat [MASK] drinking milk
Position 2: Original 'sat' → Predicted 'sat'
Position 6: Original 'while' → Predicted 'while'

Notas Clave de Implementación:

El modelo utiliza información contextual de ambas direcciones para hacer predicciones
Las predicciones se basan en distribuciones de probabilidad sobre todo el vocabulario
El proceso de enmascaramiento es aleatorizado para crear ejemplos de entrenamiento diversos
La implementación maneja eficazmente tanto tokens individuales como secuencias más largas

Predicción de la Siguiente Oración (NSP):

Ejemplo:

Oración A: "El gato se sentó en la alfombra."
Oración B: "Era un día soleado."
Resultado: "No Siguiente" (Las oraciones no están relacionadas)

Ejemplo de Código: Predicción de la Siguiente Oración

from transformers import BertTokenizer, BertForNextSentencePrediction
import torch

def check_sentence_pair(sentence_a, sentence_b):
    # Initialize tokenizer and model
    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
    model = BertForNextSentencePrediction.from_pretrained('bert-base-uncased')
    
    # Encode the sentence pair
    encoding = tokenizer(
        sentence_a,
        sentence_b,
        return_tensors='pt',
        max_length=512,
        truncation=True,
        padding='max_length'
    )
    
    # Get model prediction
    with torch.no_grad():
        outputs = model(**encoding)
        logits = outputs.logits
        prob = torch.softmax(logits, dim=1)
        
        # prob[0][0] = probability of "NotNext"
        # prob[0][1] = probability of "IsNext"
        is_next_prob = prob[0][1].item()
    
    return is_next_prob

# Example sentence pairs
sentence_pairs = [
    # Related pair (should be "IsNext")
    ("The cat sat on the mat.", "It was feeling sleepy and comfortable."),
    
    # Unrelated pair (should be "NotNext")
    ("The weather is beautiful today.", "Quantum physics explains particle behavior."),
    
    # Related pair with context
    ("Scientists discovered a new species.", "The findings were published in Nature journal."),
]

# Test each pair
for sent_a, sent_b in sentence_pairs:
    prob = check_sentence_pair(sent_a, sent_b)
    print(f"\nSentence A: {sent_a}")
    print(f"Sentence B: {sent_b}")
    print(f"Probability of B following A: {prob:.2%}")
    print(f"Prediction: {'IsNext' if prob > 0.5 else 'NotNext'}")

Desglose del Código:

Configuración del Modelo:
- Inicializa el tokenizador de BERT y el modelo NSP especializado
- Utiliza 'bert-base-uncased' que está preentrenado en tareas NSP
Procesamiento de Entrada:
- Tokeniza ambas oraciones con tokens especiales ([CLS], [SEP])
- Gestiona el relleno y truncamiento para mantener un tamaño de entrada consistente
- Devuelve tensores adecuados para el procesamiento de BERT
Predicción:
- El modelo genera logits que representan probabilidades para IsNext/NotNext
- Softmax convierte los logits en probabilidades entre 0 y 1
- Devuelve la probabilidad de que las oraciones sean consecutivas

Ejemplo de Salida:

# Expected output:
Sentence A: The cat sat on the mat.
Sentence B: It was feeling sleepy and comfortable.
Probability of B following A: 87.65%
Prediction: IsNext

Sentence A: The weather is beautiful today.
Sentence B: Quantum physics explains particle behavior.
Probability of B following A: 12.34%
Prediction: NotNext

Notas Clave de Implementación:

El modelo considera tanto las relaciones semánticas como contextuales entre oraciones
Las probabilidades más cercanas a 1 indican una mayor probabilidad de que las oraciones sean consecutivas
Se utiliza un umbral de 0.5 para tomar decisiones binarias de EsSiguiente/NoEsSiguiente
El modelo puede manejar varios tipos de relaciones, desde continuaciones directas hasta coherencia temática

5.1.4 Variantes de BERT

RoBERTa (Enfoque de Pre-entrenamiento de BERT Robustamente Optimizado)

Elimina la tarea de Predicción de la Siguiente Oración (NSP) para centrarse únicamente en el Modelado de Lenguaje Enmascarado (MLM):
- La investigación mostró que los beneficios de NSP eran mínimos en comparación con MLM
- Centrarse en MLM permite un entrenamiento más eficiente y una mejor comprensión del lenguaje
Entrena con más datos y tamaños de lote más grandes:
- Utiliza 160GB de texto en comparación con los 16GB de BERT
- Implementa tamaños de lote más grandes (8K tokens) para un entrenamiento más estable
- Entrena durante períodos más largos para lograr una mejor convergencia del modelo
Utiliza enmascaramiento dinámico para proporcionar ejemplos de entrenamiento variados:
- BERT utilizaba enmascaramiento estático aplicado una vez durante el preprocesamiento de datos
- RoBERTa genera nuevos patrones de enmascaramiento cada vez que se alimenta una secuencia al modelo
- Esto evita que el modelo memorice patrones específicos y mejora la generalización

Beneficios Principales:

Mejor rendimiento en puntos de referencia de PLN:
- Supera consistentemente a BERT en los puntos de referencia GLUE, SQuAD y RACE
- Muestra mejoras significativas en tareas de razonamiento complejo
Mayor robustez y precisión en tareas derivadas:
- Proceso de ajuste fino más estable
- Mejores capacidades de transferencia de aprendizaje para tareas de dominio específico
- Mejor rendimiento en escenarios de recursos limitados

Ejemplo de Código: Uso de RoBERTa para Clasificación de Texto

from transformers import RobertaTokenizer, RobertaForSequenceClassification
import torch
from torch.utils.data import Dataset, DataLoader

# Initialize tokenizer and model
tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
model = RobertaForSequenceClassification.from_pretrained('roberta-base', num_labels=2)

class TextDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, 
                                 max_length=max_length, return_tensors='pt')
        self.labels = torch.tensor(labels)

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = self.labels[idx]
        return item

    def __len__(self):
        return len(self.labels)

# Example training data
texts = [
    "This movie was absolutely fantastic!",
    "The plot was confusing and boring.",
    "A masterpiece of modern cinema.",
    "Waste of time and money."
]
labels = [1, 0, 1, 0]  # 1 for positive, 0 for negative

# Create dataset and dataloader
dataset = TextDataset(texts, labels, tokenizer)
loader = DataLoader(dataset, batch_size=2, shuffle=True)

# Training setup
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-5)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)

# Training loop
def train(epochs=3):
    model.train()
    for epoch in range(epochs):
        total_loss = 0
        for batch in loader:
            optimizer.zero_grad()
            
            # Move batch to device
            input_ids = batch['input_ids'].to(device)
            attention_mask = batch['attention_mask'].to(device)
            labels = batch['labels'].to(device)
            
            # Forward pass
            outputs = model(input_ids, attention_mask=attention_mask, 
                          labels=labels)
            loss = outputs.loss
            
            # Backward pass
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
            
        print(f"Epoch {epoch+1}, Average loss: {total_loss/len(loader)}")

# Prediction function
def predict(text):
    model.eval()
    with torch.no_grad():
        inputs = tokenizer(text, return_tensors='pt', 
                         truncation=True, padding=True).to(device)
        outputs = model(**inputs)
        predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
        return predictions.cpu().numpy()

# Train the model
train()

# Example prediction
test_text = "This is an amazing example of natural language processing!"
prediction = predict(test_text)
print(f"Prediction probabilities: Negative: {prediction[0][0]:.3f}, Positive: {prediction[0][1]:.3f}")

Desglose del Código:

Inicialización del Modelo y Tokenizador:
- Utiliza el tokenizador y modelo pre-entrenado de RoBERTa para clasificación de secuencias
- Configura el modelo para clasificación binaria (positivo/negativo)
Implementación del Dataset Personalizado:
- Crea una clase Dataset de PyTorch para el manejo eficiente de datos
- Gestiona la tokenización y conversión a tensores
- Implementa los métodos requeridos de Dataset de PyTorch (__getitem__, __len__)
Pipeline de Entrenamiento:
- Utiliza el optimizador AdamW con una tasa de aprendizaje pequeña para el ajuste fino
- Implementa entrenamiento independiente del dispositivo (CPU/GPU)
- Incluye un bucle completo de entrenamiento con seguimiento de pérdida
Función de Predicción:
- Implementa pipeline de inferencia para entradas de texto individuales
- Devuelve distribuciones de probabilidad para clasificación
- Maneja todo el preprocesamiento necesario automáticamente

Notas Clave de Implementación:

RoBERTa utiliza un enfoque de tokenización diferente al de BERT, optimizado para mejor rendimiento
El modelo maneja automáticamente el relleno y truncamiento para longitudes variables de texto
La implementación incluye gestión adecuada de memoria con puesta a cero de gradientes y procesamiento por lotes
El código demuestra tanto las fases de entrenamiento como de inferencia del modelo

DistilBERT:

El proceso de destilación equilibra cuidadosamente tres objetivos clave de entrenamiento:

Hacer coincidir las probabilidades objetivo suaves producidas por el modelo maestro
Mantener el mismo objetivo de modelado de lenguaje enmascarado que BERT
Preservar la similitud del coseno entre los estados ocultos del maestro y el estudiante
A través de estas optimizaciones, DistilBERT logra mejoras notables en eficiencia:
- 40% de reducción en el tamaño del modelo (de 110M a 66M parámetros)
- 60% más velocidad de procesamiento durante la inferencia
- Mantiene el 97% de las capacidades de comprensión del lenguaje de BERT

Beneficios Principales:

Ideal para implementación en entornos con recursos limitados:
- Adecuado para dispositivos móviles y computación en el borde
- La huella de memoria reducida permite más opciones de implementación
- Menores requisitos computacionales significan menor consumo de energía
Inferencia más rápida con pérdida mínima de rendimiento:
- Permite aplicaciones en tiempo real y mayor rendimiento
- Mantiene alta precisión en la mayoría de tareas de PLN
- Más rentable para implementaciones a gran escala

Ejemplo de Código: Uso de DistilBERT para Clasificación de Texto

from transformers import DistilBertTokenizer, DistilBertForSequenceClassification
import torch
from torch.utils.data import Dataset, DataLoader

# Initialize tokenizer and model
tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')
model = DistilBertForSequenceClassification.from_pretrained('distilbert-base-uncased', num_labels=2)

class TextClassificationDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, 
                                 max_length=max_length, return_tensors='pt')
        self.labels = torch.tensor(labels)

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = self.labels[idx]
        return item

    def __len__(self):
        return len(self.labels)

# Example data
texts = [
    "This product exceeded my expectations!",
    "Very disappointed with the quality.",
    "Great value for money, highly recommend.",
    "Customer service was terrible."
]
labels = [1, 0, 1, 0]  # 1: Positive, 0: Negative

# Create dataset and dataloader
dataset = TextClassificationDataset(texts, labels, tokenizer)
loader = DataLoader(dataset, batch_size=2, shuffle=True)

# Training configuration
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=5e-5)
num_epochs = 3

# Training loop
def train_model():
    model.train()
    for epoch in range(num_epochs):
        total_loss = 0
        for batch in loader:
            optimizer.zero_grad()
            
            # Move batch to device
            input_ids = batch['input_ids'].to(device)
            attention_mask = batch['attention_mask'].to(device)
            labels = batch['labels'].to(device)
            
            # Forward pass
            outputs = model(input_ids, attention_mask=attention_mask, 
                          labels=labels)
            loss = outputs.loss
            
            # Backward pass and optimization
            loss.backward()
            optimizer.step()
            
            total_loss += loss.item()
        
        avg_loss = total_loss / len(loader)
        print(f"Epoch {epoch + 1}/{num_epochs}, Average Loss: {avg_loss:.4f}")

# Inference function
def predict_sentiment(text):
    model.eval()
    with torch.no_grad():
        inputs = tokenizer(text, return_tensors='pt', 
                         truncation=True, padding=True).to(device)
        outputs = model(**inputs)
        probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
        return probs.cpu().numpy()[0]

# Train the model
train_model()

# Example prediction
test_text = "The customer support team was very helpful!"
prediction = predict_sentiment(test_text)
print(f"\nTest text: {test_text}")
print(f"Sentiment prediction: Negative: {prediction[0]:.3f}, Positive: {prediction[1]:.3f}")

Desglose del Código:

Configuración del Modelo y Tokenizador:
- Inicializa el tokenizador y modelo de clasificación de DistilBERT
- Utiliza el modelo pre-entrenado 'distilbert-base-uncased'
- Configura para clasificación binaria (sentimiento positivo/negativo)
Implementación del Dataset Personalizado:
- Crea una clase Dataset de PyTorch para el manejo eficiente de datos
- Gestiona la tokenización y conversión a tensores
- Implementa los métodos requeridos de Dataset para compatibilidad con PyTorch
Pipeline de Entrenamiento:
- Utiliza el optimizador AdamW con una tasa de aprendizaje de 5e-5
- Implementa entrenamiento independiente del dispositivo (CPU/GPU)
- Incluye seguimiento de pérdida y reporte de progreso por época
Implementación de Inferencia:
- Proporciona una función dedicada de predicción para entradas de texto individuales
- Devuelve distribuciones de probabilidad para clasificación binaria
- Maneja automáticamente todos los pasos necesarios de preprocesamiento

Notas Clave de Implementación:

El código demuestra la eficiencia de DistilBERT mientras mantiene el rendimiento similar a BERT
La implementación incluye gestión adecuada de memoria y procesamiento por lotes
El modelo maneja automáticamente el preprocesamiento y tokenización del texto
Muestra tanto las fases de entrenamiento como de inferencia con ejemplos prácticos

Ejemplo Práctico: Uso de BERT y sus Variantes

Usemos Hugging Face Transformers para cargar y ajustar BERT, RoBERTa y DistilBERT para una tarea de clasificación de texto.

Ejemplo de Código: Ajuste Fino de BERT para Análisis de Sentimiento

from transformers import BertTokenizer, BertForSequenceClassification, Trainer, TrainingArguments
from torch.utils.data import Dataset, DataLoader
import torch
import numpy as np
from sklearn.metrics import accuracy_score, precision_recall_fscore_support

# Custom Dataset Class
class SentimentDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, 
                                 max_length=max_length, return_tensors="pt")
        self.labels = torch.tensor(labels)

    def __len__(self):
        return len(self.labels)

    def __getitem__(self, idx):
        item = {key: val[idx] for key, val in self.encodings.items()}
        item['labels'] = self.labels[idx]
        return item

# Metrics computation function
def compute_metrics(pred):
    labels = pred.label_ids
    preds = pred.predictions.argmax(-1)
    precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='binary')
    acc = accuracy_score(labels, preds)
    return {
        'accuracy': acc,
        'f1': f1,
        'precision': precision,
        'recall': recall
    }

# Load pre-trained BERT and tokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
model = BertForSequenceClassification.from_pretrained(
    "bert-base-uncased",
    num_labels=2,
    output_attentions=True
)

# Example data
texts = [
    "The movie was fantastic!",
    "I did not enjoy the food.",
    "This is the best book I've ever read!",
    "The service was terrible and slow.",
    "Absolutely loved the experience!"
]
labels = [1, 0, 1, 0, 1]  # 1 = Positive, 0 = Negative

# Create datasets
train_dataset = SentimentDataset(texts, labels, tokenizer)

# Define training arguments
training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
    logging_dir='./logs',
    logging_steps=10,
    load_best_model_at_end=True,
    metric_for_best_model='f1',
    save_strategy="epoch"
)

# Initialize trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    compute_metrics=compute_metrics
)

# Train the model
trainer.train()

# Example inference
def predict_sentiment(text):
    # Prepare input
    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
    
    # Get prediction
    with torch.no_grad():
        outputs = model(**inputs)
        probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
        prediction = torch.argmax(probabilities, dim=-1)
    
    return {
        "text": text,
        "sentiment": "Positive" if prediction == 1 else "Negative",
        "confidence": float(probabilities[0][prediction])
    }

# Test predictions
test_texts = [
    "I would highly recommend this product!",
    "This was a complete waste of money."
]

for text in test_texts:
    result = predict_sentiment(text)
    print(f"\nText: {result['text']}")
    print(f"Sentiment: {result['sentiment']}")
    print(f"Confidence: {result['confidence']:.4f}")

Desglose y Explicación del Código:

Implementación del Dataset Personalizado:
- Crea una clase Dataset personalizada de PyTorch (SentimentDataset)
- Maneja la tokenización y conversión de datos de texto a tensores
- Implementa los métodos requeridos de Dataset (__len__, __getitem__)
Configuración y Preparación del Modelo:
- Inicializa el tokenizador y modelo de clasificación BERT
- Configura para clasificación binaria de sentimientos
- Habilita las salidas de atención para análisis potencial
Configuración del Entrenamiento:
- Define argumentos completos de entrenamiento
- Implementa configuraciones de tasa de aprendizaje y tamaño de lote
- Incluye estrategias de registro y guardado del modelo
Métricas y Evaluación:
- Implementa la función compute_metrics para seguimiento del rendimiento
- Calcula precisión, puntuación F1, precisión y exhaustividad
- Permite la evaluación del modelo durante el entrenamiento
Pipeline de Inferencia:
- Crea una función dedicada de predicción
- Maneja entradas de texto individuales con preprocesamiento adecuado
- Devuelve resultados detallados de predicción con puntuaciones de confianza

5.1.5 Casos de Uso Clave de BERT y sus Variantes

Clasificación de Texto:

Respuesta a Preguntas:

La destreza del modelo en respuesta a preguntas proviene de su capacidad para:

Procesar relaciones semánticas entre palabras y frases a través de largas distancias en el texto
Comprender diversos tipos de preguntas, desde consultas factuales hasta preguntas de razonamiento más abstracto
Considerar múltiples niveles de contexto simultáneamente, desde la comprensión a nivel de palabra hasta nivel de oración
Generar respuestas contextualmente apropiadas sintetizando información de diferentes partes del pasaje

Ejemplo de Código: Respuesta a Preguntas con BERT

from transformers import AutoTokenizer, AutoModelForQuestionAnswering
import torch

def setup_qa_model():
    # Initialize tokenizer and model
    tokenizer = AutoTokenizer.from_pretrained("bert-large-uncased-whole-word-masking-finetuned-squad")
    model = AutoModelForQuestionAnswering.from_pretrained("bert-large-uncased-whole-word-masking-finetuned-squad")
    return tokenizer, model

def answer_question(question, context, tokenizer, model):
    # Tokenize input text
    inputs = tokenizer(
        question,
        context,
        add_special_tokens=True,
        return_tensors="pt",
        max_length=512,
        truncation=True,
        padding='max_length'
    )
    
    # Get model predictions
    with torch.no_grad():
        outputs = model(**inputs)
        answer_start = outputs.start_logits.argmax()
        answer_end = outputs.end_logits.argmax()
    
    # Convert token positions to text
    tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
    answer = tokenizer.convert_tokens_to_string(tokens[answer_start:answer_end + 1])
    
    # Calculate confidence scores
    start_scores = torch.softmax(outputs.start_logits, dim=1)[0]
    end_scores = torch.softmax(outputs.end_logits, dim=1)[0]
    confidence = float((start_scores[answer_start] * end_scores[answer_end]).item())
    
    return {
        "answer": answer,
        "confidence": confidence,
        "start": answer_start,
        "end": answer_end
    }

# Example usage
tokenizer, model = setup_qa_model()

context = """
The Transformer architecture was introduced in the paper 'Attention Is All You Need' 
by Vaswani et al. in 2017. BERT, which stands for Bidirectional Encoder Representations 
from Transformers, was developed by researchers at Google AI Language in 2018. It 
revolutionized NLP by introducing bidirectional training and achieving state-of-the-art 
results on various language tasks.
"""

questions = [
    "When was the Transformer architecture introduced?",
    "Who developed BERT?",
    "What does BERT stand for?"
]

for question in questions:
    result = answer_question(question, context, tokenizer, model)
    print(f"\nQuestion: {question}")
    print(f"Answer: {result['answer']}")
    print(f"Confidence: {result['confidence']:.4f}")

Desglose del código:

Configuración e Inicialización del Modelo:
- Utiliza un modelo BERT pre-entrenado específicamente ajustado para responder preguntas en el conjunto de datos SQuAD
- Inicializa tanto el tokenizador como el modelo desde la biblioteca transformers de Hugging Face
Implementación de la Función de Respuesta a Preguntas:
- Maneja el preprocesamiento de entrada con tokenización adecuada
- Gestiona la longitud máxima de secuencia y el truncamiento
- Implementa procesamiento por lotes eficiente con PyTorch
Proceso de Extracción de Respuestas:
- Identifica las posiciones de inicio y fin de la respuesta en el texto
- Convierte las posiciones de tokens a texto legible
- Calcula puntuaciones de confianza para las predicciones
Procesamiento de Resultados:
- Devuelve una salida estructurada con la respuesta, puntuación de confianza e información de posición
- Maneja casos extremos y posibles errores en la extracción de respuestas
- Proporciona métricas de confianza significativas para la fiabilidad de las respuestas

Reconocimiento de Entidades Nombradas (NER)

Nombres de personas, incluyendo variaciones y apodos
Expresiones temporales como fechas, horas y duraciones
Ubicaciones geográficas a diferentes escalas (ciudades, países, puntos de referencia)
Nombres de organizaciones, incluyendo empresas, instituciones y organismos gubernamentales
Nombres de productos y marcas en diferentes industrias
Valores monetarios en varias monedas y formatos
Entidades personalizadas específicas para dominios o industrias particulares

Esta sofisticada funcionalidad de reconocimiento de entidades sirve como piedra angular para numerosas aplicaciones prácticas:

Revisión de Documentos Legales: Identificación automática de partes, fechas, montos monetarios y entidades legales
Análisis de Registros Médicos: Extracción de información del paciente, condiciones médicas, medicamentos y fechas de tratamiento
Inteligencia Empresarial: Seguimiento de menciones de empresas, referencias de productos y tendencias del mercado
Investigación y Academia: Identificación de citas, nombres de autores y afiliaciones institucionales
Análisis Financiero: Detección de nombres de empresas, valores monetarios y detalles de transacciones
Noticias y Medios: Categorización de personas, organizaciones y ubicaciones en artículos de noticias

Ejemplo de Código: Reconocimiento de Entidades Nombradas con BERT

from transformers import AutoTokenizer, AutoModelForTokenClassification
import torch
from torch.nn import functional as F

def setup_ner_model():
    # Initialize tokenizer and model for NER
    tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")
    model = AutoModelForTokenClassification.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")
    return tokenizer, model

def perform_ner(text, tokenizer, model):
    # Tokenize input text
    inputs = tokenizer(
        text,
        add_special_tokens=True,
        return_tensors="pt",
        truncation=True,
        max_length=512
    )
    
    # Get predictions
    with torch.no_grad():
        outputs = model(**inputs)
        predictions = F.softmax(outputs.logits, dim=-1)
        predictions = torch.argmax(predictions, dim=-1)
    
    # Process tokens and predictions
    tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
    label_list = model.config.id2label
    
    entities = []
    current_entity = None
    
    for idx, (token, pred) in enumerate(zip(tokens, predictions[0])):
        label = label_list[pred.item()]
        
        # Skip special tokens
        if token in [tokenizer.sep_token, tokenizer.cls_token, tokenizer.pad_token]:
            continue
            
        # Handle B- (beginning) and I- (inside) tags
        if label.startswith("B-"):
            if current_entity:
                entities.append(current_entity)
            current_entity = {
                "entity": token.replace("##", ""),
                "type": label[2:],
                "start": idx
            }
        elif label.startswith("I-") and current_entity:
            current_entity["entity"] += token.replace("##", "")
        elif label == "O":  # Outside any entity
            if current_entity:
                entities.append(current_entity)
                current_entity = None
    
    if current_entity:
        entities.append(current_entity)
    
    return entities

# Example usage
def demonstrate_ner():
    tokenizer, model = setup_ner_model()
    
    sample_text = """
    Apple Inc. CEO Tim Cook announced a new partnership with Microsoft 
    Corporation in New York City last Friday. The deal, worth $5 billion, 
    will help both companies expand their presence in the artificial 
    intelligence market.
    """
    
    entities = perform_ner(sample_text, tokenizer, model)
    
    # Print results
    for entity in entities:
        print(f"Entity: {entity['entity']}")
        print(f"Type: {entity['type']}")
        print("---")

Desglose y Explicación del Código:

Inicialización y Configuración del Modelo:
- Utiliza un modelo BERT pre-entrenado específicamente ajustado para tareas de NER
- Aprovecha la biblioteca transformers de Hugging Face para la configuración del modelo y tokenizador
- Configura el modelo para la clasificación de tokens con etiquetas de entidades
Función de Procesamiento NER:
- Implementa tokenización eficiente con manejo adecuado de tokens especiales
- Gestiona limitaciones de longitud de secuencia y truncamiento
- Utiliza el contexto no_grad de PyTorch para inferencia eficiente
Reconocimiento y Procesamiento de Entidades:
- Maneja el esquema de etiquetado BIO (Principio, Dentro, Fuera)
- Procesa tokens parciales y reconstruye entidades completas
- Mantiene con precisión los límites y tipos de entidades
Procesamiento de Salida:
- Crea una salida estructurada con texto de entidad, tipo e información de posición
- Maneja casos extremos y reconstrucción de tokens
- Proporciona resultados limpios y organizados de extracción de entidades

Tareas con Recursos Limitados:

Los logros clave de DistilBERT son impresionantes:

Retención de Rendimiento: Preserva aproximadamente el 97% de las capacidades de comprensión del lenguaje de BERT, asegurando resultados de alta calidad
Optimización de Tamaño: El modelo logra una reducción del 40% en tamaño comparado con BERT, requiriendo significativamente menos espacio de almacenamiento
Mejora de Velocidad: La velocidad de procesamiento aumenta en un 60%, permitiendo tiempos de inferencia más rápidos y mejor capacidad de respuesta

Estas mejoras hacen que DistilBERT sea particularmente valioso para varias aplicaciones del mundo real:

Aplicaciones Móviles: Permite características sofisticadas de PLN en smartphones y tablets sin consumo excesivo de batería o requisitos de almacenamiento
Computación de Borde: Permite el procesamiento local en dispositivos IoT y servidores edge, reduciendo la necesidad de conectividad en la nube
Sistemas en Tiempo Real: Admite aplicaciones que requieren respuestas inmediatas, como traducción en vivo o análisis de mensajes instantáneos
Entornos con Recursos Limitados: Hace el PLN avanzado accesible en entornos con poder computacional o memoria limitados

Ejemplo de Código: Tareas con Recursos Limitados usando DistilBERT

from transformers import DistilBertTokenizer, DistilBertForSequenceClassification
import torch
from torch.nn import functional as F

def setup_distilbert():
    # Initialize tokenizer and model
    tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')
    model = DistilBertForSequenceClassification.from_pretrained(
        'distilbert-base-uncased',
        num_labels=2  # Binary classification
    )
    return tokenizer, model

def optimize_model_for_inference(model):
    # Convert to inference mode
    model.eval()
    # Quantize model to reduce memory footprint
    model = torch.quantization.quantize_dynamic(
        model, {torch.nn.Linear}, dtype=torch.qint8
    )
    return model

def process_text(text, tokenizer, model, max_length=128):
    # Tokenize with truncation
    inputs = tokenizer(
        text,
        truncation=True,
        max_length=max_length,
        padding='max_length',
        return_tensors='pt'
    )
    
    # Efficient inference
    with torch.no_grad():
        outputs = model(**inputs)
        predictions = F.softmax(outputs.logits, dim=-1)
    
    return predictions

def batch_process_texts(texts, tokenizer, model, batch_size=16):
    results = []
    
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        batch_predictions = process_text(batch, tokenizer, model)
        results.extend(batch_predictions.tolist())
    
    return results

# Example usage
def demonstrate_resource_constrained_classification():
    tokenizer, model = setup_distilbert()
    model = optimize_model_for_inference(model)
    
    sample_texts = [
        "This product works great and I'm very satisfied!",
        "The quality is terrible, would not recommend.",
        "Decent product for the price point."
    ]
    
    predictions = batch_process_texts(sample_texts, tokenizer, model)
    
    for text, pred in zip(sample_texts, predictions):
        sentiment = "Positive" if pred[1] > 0.5 else "Negative"
        confidence = max(pred)
        print(f"Text: {text}")
        print(f"Sentiment: {sentiment} (Confidence: {confidence:.2f})")
        print("---")

Desglose del Código:

Configuración y Optimización del Modelo:
- Inicializa DistilBERT con una configuración mínima para clasificación de secuencias
- Implementa la cuantización del modelo para reducir el uso de memoria
- Configura el modelo para un modo de inferencia eficiente
Función de Procesamiento de Texto:
- Implementa tokenización eficiente con restricciones de longitud
- Utiliza procesamiento por lotes dinámico para un uso óptimo de recursos
- Gestiona la memoria eficientemente con el contexto no_grad
Técnicas de Optimización de Recursos:
- Emplea cuantización del modelo para reducir la huella de memoria
- Implementa procesamiento por lotes para maximizar el rendimiento
- Utiliza estrategias de truncamiento y relleno para gestionar longitudes de secuencia
Consideraciones de Rendimiento:
- Equilibra el tamaño del lote con las restricciones de memoria
- Implementa agregación eficiente de predicciones
- Proporciona puntuaciones de confianza para la fiabilidad de las predicciones

5.1.6 Puntos Clave

BERT (Representaciones Codificadas Bidireccionales de Transformers) trajo un cambio fundamental al PLN al introducir incrustaciones bidireccionales conscientes del contexto. A diferencia de los modelos anteriores que procesaban texto en una dirección, BERT analiza las palabras en relación con todas las demás palabras en una oración simultáneamente. Esta innovación, combinada con su enfoque de pre-entrenamiento/ajuste fino, permite que el modelo desarrolle una comprensión profunda del contexto y matices del lenguaje. Durante el pre-entrenamiento, BERT aprende de cantidades masivas de texto prediciendo palabras enmascaradas y comprendiendo relaciones entre oraciones. Luego, mediante el ajuste fino, puede adaptarse para tareas específicas mientras mantiene su comprensión fundamental del lenguaje.
El éxito de BERT inspiró varias variantes importantes. RoBERTa (Enfoque BERT Robustamente Optimizado) mejoró la arquitectura original modificando el proceso de pre-entrenamiento - usando lotes más grandes de datos, entrenando durante períodos más largos y eliminando la tarea de predicción de la siguiente oración. Estas optimizaciones condujeron a mejoras significativas en el rendimiento. Mientras tanto, DistilBERT abordó los desafíos prácticos de implementación creando una versión más ligera que mantiene la mayoría de las capacidades de BERT mientras usa menos recursos computacionales. Esto se logró mediante la destilación del conocimiento, donde un modelo más pequeño aprende a replicar el comportamiento del modelo más grande, haciendo que las potentes capacidades de PLN sean accesibles para organizaciones con recursos computacionales limitados.
El impacto práctico de estos modelos ha sido notable. En clasificación de texto, logran alta precisión en la categorización de documentos, correos electrónicos y publicaciones en redes sociales. Para respuesta a preguntas, pueden entender consultas complejas y extraer información relevante de textos largos. En análisis de sentimientos, sobresalen en detectar sutiles matices emocionales en el texto. Su versatilidad se extiende a tareas como reconocimiento de entidades nombradas, resumen de texto y traducción de idiomas, donde consistentemente superan los enfoques tradicionales. Esta combinación de alto rendimiento y eficiencia los ha convertido en la base de numerosas aplicaciones del mundo real en industrias que van desde la atención médica hasta el servicio al cliente.

Compra este libro