Click here to view the next lesson.

Capítulo 6: Aplicaciones centrales de PLN

6.3 Clasificación de Texto

La clasificación de texto se erige como una de las aplicaciones fundamentales en el procesamiento del lenguaje natural (PLN), representando una capacidad fundamental que sustenta numerosas aplicaciones modernas. En su esencia, la clasificación de texto implica el proceso sistemático de analizar contenido textual y asignarlo a una o más categorías predefinidas basándose en sus características, contexto y significado. Este proceso de categorización automatizada se ha vuelto cada vez más sofisticado con los enfoques modernos de aprendizaje automático.

Las aplicaciones de la clasificación de texto abarcan diversos campos y casos de uso, incluyendo:

Detección de Spam: Más allá de la simple categorización "spam" o "no spam", los sistemas modernos analizan múltiples aspectos de los correos electrónicos, incluyendo patrones de contenido, reputación del remitente y señales contextuales para proteger a los usuarios de comunicaciones no deseadas o maliciosas.
Clasificación por Temas: Los sistemas avanzados ahora pueden categorizar contenido a través de cientos de temas y subtemas, permitiendo una organización precisa del contenido en agregadores de noticias, sistemas de gestión de contenido y bases de datos de investigación. Los ejemplos se extienden más allá de deportes y política para incluir temas técnicos, disciplinas académicas y temas emergentes.
Análisis de Sentimiento: El análisis de sentimiento moderno va más allá de las clasificaciones básicas positivo/negativo/neutral para detectar matices emocionales sutiles, sarcasmo y opiniones dependientes del contexto. Esto permite a las empresas obtener percepciones más profundas sobre el feedback de los clientes y las reacciones en redes sociales.
Reconocimiento de Intención: Los sistemas contemporáneos de reconocimiento de intención pueden identificar intenciones complejas del usuario en IA conversacional, incluyendo solicitudes de múltiples pasos, intenciones implícitas y consultas dependientes del contexto. Esta capacidad es crucial para crear interacciones humano-computadora más naturales y efectivas.

El surgimiento de las arquitecturas Transformer, particularmente BERT y sus variantes, ha revolucionado la clasificación de texto al introducir niveles sin precedentes de comprensión contextual. Estos modelos pueden captar matices lingüísticos sutiles, comprender dependencias de largo alcance en el texto y adaptarse a terminología específica del dominio, resultando en sistemas de clasificación que se aproximan a la precisión humana en muchas tareas. Este avance tecnológico ha permitido el desarrollo de aplicaciones de clasificación de texto más confiables, escalables y sofisticadas en todas las industrias.

6.3.1 ¿Por qué usar Transformers para la clasificación de texto?

Los Transformers han revolucionado la clasificación de texto al ofrecer varias ventajas revolucionarias:

Comprensión Contextual

Los métodos tradicionales como bag-of-words o enfoques estadísticos tienen limitaciones significativas porque procesan las palabras como unidades aisladas sin considerar sus relaciones. En contraste, los Transformers representan un salto cuántico al utilizar mecanismos sofisticados de atención que analizan cómo cada palabra se relaciona con todas las demás palabras en el texto. Este enfoque revolucionario permite una comprensión contextual profunda del lenguaje. Esto significa que pueden:

Captar el significado matizado de las palabras basándose en su contexto circundante - Por ejemplo, entender que "banco" significa una institución financiera cuando se usa cerca de palabras como "dinero" o "cuenta", pero significa la orilla de un río cuando se usa cerca de palabras como "río" o "corriente"
Comprender dependencias de largo alcance entre oraciones - El modelo puede conectar conceptos relacionados incluso cuando aparecen separados por varias oraciones, de manera similar a cómo los humanos mantienen el contexto durante una conversación
Reconocer patrones lingüísticos sutiles y modismos - En lugar de tomar las frases literalmente, los Transformers pueden entender el lenguaje figurado y expresiones comunes analizando cómo estas frases se utilizan típicamente en contexto
Manejar la ambigüedad considerando el contexto completo de uso - Cuando se encuentran con palabras o frases que podrían tener múltiples significados, el modelo evalúa todo el contexto para determinar la interpretación más apropiada, similar a cómo los humanos resuelven la ambigüedad en la conversación natural

Aprendizaje por Transferencia

El poder del aprendizaje por transferencia en los Transformers representa un avance revolucionario en el PLN. Este enfoque permite que los modelos construyan sobre el conocimiento previamente aprendido, similar a cómo los humanos aplican experiencias pasadas a nuevas situaciones. Modelos como BERT, RoBERTa y DistilBERT se someten a un pre-entrenamiento extensivo en corpus de texto masivos - que a menudo contienen miles de millones de palabras en diversos temas y estilos. Esta fase de pre-entrenamiento permite que los modelos desarrollen una comprensión profunda de la estructura del lenguaje, la gramática y las relaciones contextuales.

Durante el pre-entrenamiento, estos modelos aprenden a predecir palabras enmascaradas y entender relaciones entre oraciones, desarrollando una rica representación interna del lenguaje. Este conocimiento puede adaptarse eficientemente a tareas específicas mediante el ajuste fino, que requiere solo una pequeña cantidad de datos de entrenamiento y recursos computacionales específicos para la tarea. Este enfoque ofrece varios beneficios significativos:

Reduce la necesidad de grandes conjuntos de datos de entrenamiento específicos para cada tarea
- Los enfoques tradicionales de aprendizaje automático a menudo requerían decenas de miles de ejemplos etiquetados
- El aprendizaje por transferencia puede lograr excelentes resultados con solo cientos de ejemplos
- Particularmente valioso para dominios especializados donde los datos etiquetados son escasos
Preserva la comprensión general del lenguaje mientras se adapta a dominios específicos
- Mantiene un amplio conocimiento de patrones y estructuras del lenguaje
- Se adapta exitosamente a terminología y convenciones específicas del dominio
- Equilibra efectivamente el conocimiento general y especializado
Permite una implementación rápida para nuevos casos de uso
- Reduce significativamente el tiempo de desarrollo comparado con el entrenamiento desde cero
- Permite una adaptación rápida a requisitos emergentes
- Facilita la mejora iterativa y la experimentación
Logra un rendimiento estado del arte con un entrenamiento específico mínimo
- A menudo supera a los modelos tradicionales entrenados desde cero
- Requiere menos tiempo de ajuste fino y recursos computacionales
- Demuestra una generalización superior a nuevos ejemplos

Versatilidad

La adaptabilidad de los Transformers a través de diferentes dominios demuestra su notable versatilidad. Su arquitectura sofisticada les permite procesar y comprender contenido especializado en una amplia gama de industrias y aplicaciones. Sobresalen en varios sectores:

Salud: Procesamiento de registros médicos y artículos de investigación, incluyendo terminología compleja, diagnósticos, protocolos de tratamiento y datos de ensayos clínicos. Estos modelos pueden identificar entidades médicas clave y relaciones mientras mantienen los estándares de privacidad del paciente.
Finanzas: Análisis de informes de mercado y documentos financieros, desde informes trimestrales de ganancias hasta evaluaciones de riesgo. Pueden procesar terminología financiera compleja, datos numéricos y requisitos de cumplimiento regulatorio mientras comprenden el contexto específico del mercado.
Servicio al Cliente: Comprensión de consultas y retroalimentación de clientes a través de múltiples canales, incluyendo correos electrónicos, registros de chat y redes sociales. Pueden detectar el sentimiento del cliente, la urgencia y la intención mientras manejan múltiples idiomas y estilos de comunicación.
Legal: Procesamiento de documentos legales y jurisprudencia, incluyendo contratos, patentes y decisiones judiciales. Estos modelos pueden comprender terminología legal compleja, precedentes y variaciones jurisdiccionales mientras mantienen la precisión en interpretaciones legales sensibles.

Esta capacidad interdominios es posible porque los Transformers pueden aprender y adaptarse efectivamente a vocabularios especializados y estructuras lingüísticas únicas dentro de cada campo. Su arquitectura les permite capturar matices específicos del dominio, terminología técnica y relaciones contextuales mientras mantienen una alta precisión a través de diferentes contextos profesionales.

Esta adaptabilidad se ve además mejorada por su capacidad para transferir el aprendizaje de un dominio a otro, haciéndolos particularmente valiosos para aplicaciones especializadas que requieren una comprensión profunda del lenguaje y conceptos específicos del campo.

6.3.2 Pasos para la Clasificación de Texto con Transformers

Profundicemos en el proceso integral de implementación de clasificación de texto usando modelos Transformer pre-entrenados. Entender cada etapa en detalle es crucial para una implementación exitosa:

1. Preparación de Datos

Un primer paso crucial en la clasificación de texto implica preparar y preprocesar cuidadosamente tus datos para asegurar un rendimiento óptimo del modelo. Este proceso integral de preparación de datos incluye:

Limpieza y Estandarización

Eliminar caracteres irrelevantes, símbolos especiales y espacios en blanco innecesarios
- Eliminar etiquetas HTML y artefactos de formato
- Eliminar o reemplazar caracteres no imprimibles
- Estandarizar caracteres Unicode y codificaciones
Manejar valores faltantes e inconsistencias en el texto
- Identificar y manejar valores NULL apropiadamente
- Tratar con entradas de texto truncadas o corruptas
- Estandarizar patrones de formato inconsistentes
Normalizar texto (ej., minúsculas, eliminar acentos)
- Convertir todo el texto a un formato consistente (típicamente minúsculas)
- Eliminar o estandarizar marcas diacríticas
- Estandarizar puntuación y espaciado
Dividir datos en conjuntos de entrenamiento, validación y prueba
- Típicamente usar 70-80% para entrenamiento
- 10-15% para validación durante el desarrollo del modelo
- 10-15% para pruebas finales y evaluación
- Asegurar una distribución equilibrada de clases entre las divisiones

Ejemplo: Pipeline de Preparación de Datos

import pandas as pd
import re
from sklearn.model_selection import train_test_split

def clean_text(text):
    # Remove HTML tags
    text = re.sub(r'<[^>]+>', '', text)
    
    # Remove special characters and digits
    text = re.sub(r'[^a-zA-Z\s]', '', text)
    
    # Convert to lowercase
    text = text.lower()
    
    # Remove extra whitespace
    text = ' '.join(text.split())
    
    return text

# Load raw data
df = pd.read_csv('raw_data.csv')

# Clean text data
df['cleaned_text'] = df['text'].apply(clean_text)

# Split data while maintaining class distribution
train_data, temp_data = train_test_split(
    df, 
    test_size=0.3,
    stratify=df['label'],
    random_state=42
)

# Split temp data into validation and test sets
val_data, test_data = train_test_split(
    temp_data,
    test_size=0.5,
    stratify=temp_data['label'],
    random_state=42
)

print(f"Training samples: {len(train_data)}")
print(f"Validation samples: {len(val_data)}")
print(f"Test samples: {len(test_data)}")

Aquí está el desglose de sus componentes principales:

Importaciones y Configuración

Utiliza pandas para el manejo de datos, re para expresiones regulares y sklearn para la división de datos

Función de Limpieza de Texto

La función clean_text() realiza varios pasos de preprocesamiento:

Elimina etiquetas HTML
Elimina caracteres especiales y dígitos
Convierte el texto a minúsculas
Elimina espacios en blanco extra

Carga y Limpieza de Datos

Carga datos desde un archivo CSV
Aplica la función de limpieza a la columna de texto

División de Datos

El código implementa una división en dos etapas de los datos:

Primera división: 70% entrenamiento, 30% datos temporales
Segunda división: Los datos temporales se dividen equitativamente entre conjuntos de validación y prueba
Utiliza estratificación para mantener la distribución de clases en todas las divisiones

Resultados

La distribución final del conjunto de datos:

Conjunto de entrenamiento: 7,000 muestras
Conjunto de validación: 1,500 muestras
Conjunto de prueba: 1,500 muestras

Esta división sigue la práctica recomendada de usar 70-80% para entrenamiento y 10-15% cada uno para validación y pruebas.

Salida Esperada:

Training samples: 7000
Validation samples: 1500
Test samples: 1500

2. Selección del Modelo: Consideraciones Clave

La elección de un modelo Transformer pre-entrenado apropiado requiere una evaluación cuidadosa de varios factores críticos:

Considerar factores como el tamaño del modelo, requisitos computacionales y soporte de idiomas:
- El tamaño del modelo afecta el uso de memoria y la velocidad de inferencia
- Los requisitos de GPU/CPU impactan los costos de implementación
- El soporte de idiomas determina las capacidades multilingües
Las opciones populares incluyen:
- BERT: Excelente para tareas de clasificación de propósito general
- RoBERTa: Versión mejorada de BERT con entrenamiento optimizado
- DistilBERT: Variante más ligera y rápida, ideal para restricciones de recursos
- XLNet: Modelo avanzado mejor en el manejo de dependencias de largo alcance
Evaluar el equilibrio entre la complejidad del modelo y las necesidades de rendimiento:
- Los modelos más grandes generalmente ofrecen mejor precisión pero inferencia más lenta
- Los modelos más pequeños proporcionan procesamiento más rápido pero pueden sacrificar algo de precisión
- Considerar los requisitos y restricciones específicos de tu caso de uso

Ejemplo: Guía de Selección de Modelo

from transformers import AutoModelForSequenceClassification, AutoTokenizer

def select_model(task_requirements):
    if task_requirements['computational_resources'] == 'limited':
        # Lightweight model for resource-constrained environments
        model_name = "distilbert-base-uncased"
        max_length = 256
    elif task_requirements['language'] == 'multilingual':
        # Multilingual model for cross-language tasks
        model_name = "xlm-roberta-base"
        max_length = 512
    else:
        # Full-size model for maximum accuracy
        model_name = "roberta-large"
        max_length = 512
    
    # Load model and tokenizer
    model = AutoModelForSequenceClassification.from_pretrained(model_name)
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    
    return model, tokenizer, max_length

# Example usage
requirements = {
    'computational_resources': 'limited',
    'language': 'english',
    'task': 'sentiment_analysis'
}

model, tokenizer, max_length = select_model(requirements)
print(f"Selected model: {model.config.model_type}")
print(f"Model parameters: {model.num_parameters():,}")
print(f"Maximum sequence length: {max_length}")

Aquí está el desglose de sus componentes principales:

Definición de la Función:

La función select_model elige un modelo pre-entrenado apropiado basado en requisitos específicos de la tarea:

Para recursos computacionales limitados: Utiliza DistilBERT (un modelo ligero) con longitud de secuencia de 256
Para tareas multilingües: Utiliza XLM-RoBERTa con longitud de secuencia de 512
Para máxima precisión: Utiliza RoBERTa-large con longitud de secuencia de 512

Lógica de Selección del Modelo:

La función considera tres factores principales:

Tamaño del modelo y uso de memoria
Requisitos de GPU/CPU
Capacidades de soporte de idiomas

Ejemplo de Implementación:

El código incluye un ejemplo práctico usando estos requisitos:

Recursos computacionales limitados
Idioma inglés
Tarea de análisis de sentimiento

En este caso, selecciona DistilBERT como modelo, que se muestra en la salida con aproximadamente 66 millones de parámetros y una longitud máxima de secuencia de 256.

Esta implementación permite una selección flexible del modelo mientras equilibra el compromiso entre la complejidad del modelo y las necesidades de rendimiento.

Salida Esperada:

Selected model: distilbert
Model parameters: 66,362,880
Maximum sequence length: 256

3. Tokenización

La tokenización es un paso crucial de preprocesamiento que convierte el texto sin procesar en un formato que los modelos Transformer pueden entender y procesar. Este proceso implica dividir el texto en unidades más pequeñas llamadas tokens, que sirven como elementos fundamentales de entrada para el modelo.

El proceso de tokenización implica varios pasos clave:

Dividir el texto en unidades más pequeñas:
- Palabras: Dividir el texto en los límites de las palabras (ej., "hola mundo" → ["hola", "mundo"])
- Subpalabras: Dividir palabras complejas en partes significativas (ej., "jugando" → ["jug", "##ando"])
- Caracteres: En algunos casos, dividir el texto en caracteres individuales para un procesamiento más granular
Aplicar reglas de tokenización específicas del modelo:
- WordPiece (BERT): Divide las palabras en unidades de subpalabras comunes
- BPE (GPT): Utiliza codificación por pares de bytes para encontrar pares de tokens comunes
- SentencePiece: Trata el texto como una secuencia de caracteres unicode
Manejar tokens especiales que tienen funciones específicas:
- [CLS]: Token de clasificación, usado para tareas a nivel de oración
- [SEP]: Token separador, marca los límites entre oraciones
- [PAD]: Tokens de relleno, usados para mantener longitudes de entrada consistentes
- [MASK]: Usado en el modelado de lenguaje enmascarado durante el pre-entrenamiento

Ejemplo: Implementación de Tokenización

from transformers import AutoTokenizer

def demonstrate_tokenization(text):
    # Initialize tokenizer (using BERT as example)
    tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
    
    # Basic tokenization
    tokens = tokenizer.tokenize(text)
    
    # Convert tokens to ids
    input_ids = tokenizer.convert_tokens_to_ids(tokens)
    
    # Create attention mask
    attention_mask = [1] * len(input_ids)
    
    # Add special tokens and pad sequence
    encoded = tokenizer(
        text,
        padding='max_length',
        truncation=True,
        max_length=128,
        return_tensors='pt'
    )
    
    return {
        'original_text': text,
        'tokens': tokens,
        'input_ids': input_ids,
        'encoded': encoded
    }

# Example usage
text = "The quick brown fox jumps over the lazy dog!"
result = demonstrate_tokenization(text)

print("Original text:", result['original_text'])
print("\nTokens:", result['tokens'])
print("\nInput IDs:", result['input_ids'])
print("\nFull encoding:", result['encoded'])

Analicemos lo que está sucediendo en este ejemplo:

Proceso de Tokenización:
- El tokenizador primero divide el texto en tokens usando la tokenización WordPiece
- Algunas palabras se dividen en subpalabras (por ejemplo, "jumps" → ["jump", "##s"])
- Se añaden tokens especiales ([CLS] al inicio, [SEP] al final)
Componentes Clave:
- input_ids: Representaciones numéricas de los tokens
- attention_mask: Indica qué tokens son de relleno (0) vs. tokens reales (1)
- La salida codificada incluye tensores listos para la entrada del modelo

Este ejemplo muestra cómo el texto sin procesar se transforma en un formato que los modelos Transformer pueden procesar, incluyendo el manejo de tokens especiales, relleno y máscaras de atención.

Salida Esperada:

Original text: The quick brown fox jumps over the lazy dog!

Tokens: ['the', 'quick', 'brown', 'fox', 'jump', '##s', 'over', 'the', 'lazy', 'dog', '!']

Input IDs: [1996, 4248, 2829, 4419, 4083, 2015, 2058, 1996, 3910, 3899, 999]

Full encoding: {
    'input_ids': tensor([[  101,  1996,  4248,  2829,  4419,  4083,  2015,  2058,  1996,  3910,
                           3899,   999,   102,     0,     0, ...]),
    'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, ...]])
}

4. Ajuste fino (opcional): Adaptación y Optimización del Modelo

El ajuste fino implica adaptar un modelo pre-entrenado a tu caso de uso específico mediante el ajuste cuidadoso de parámetros y la configuración del entrenamiento. Este proceso requiere:

Ajustar los parámetros del modelo usando datos etiquetados específicos del dominio:
- Seleccionar cuidadosamente ejemplos de entrenamiento representativos de tu dominio
- Equilibrar las distribuciones de clases para prevenir sesgos
- Considerar la aumentación de datos para conjuntos de datos limitados
Configurar la tasa de aprendizaje, tamaño de lote y número de épocas de entrenamiento:
- Comenzar con una tasa de aprendizaje pequeña (típicamente 2e-5 a 5e-5) para prevenir el olvido catastrófico
- Elegir el tamaño de lote basado en la memoria disponible y recursos computacionales
- Determinar el número óptimo de épocas mediante el rendimiento de validación
Implementar parada temprana y puntos de control del modelo:
- Monitorear métricas de validación para prevenir el sobreajuste
- Guardar los estados del modelo con mejor rendimiento durante el entrenamiento
- Usar callbacks para detener automáticamente el entrenamiento cuando el rendimiento se estabiliza

Ejemplo: Implementación del Ajuste Fino

from transformers import AutoModelForSequenceClassification, AutoTokenizer, Trainer, TrainingArguments
import torch
from torch.utils.data import Dataset
import numpy as np
from sklearn.metrics import accuracy_score, precision_recall_fscore_support

# Custom dataset class
class CustomDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, max_length=max_length)
        self.labels = labels

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

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

# 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='weighted')
    acc = accuracy_score(labels, preds)
    return {
        'accuracy': acc,
        'f1': f1,
        'precision': precision,
        'recall': recall
    }

def fine_tune_model(train_texts, train_labels, val_texts, val_labels):
    # Initialize tokenizer and model
    tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
    model = AutoModelForSequenceClassification.from_pretrained(
        'bert-base-uncased',
        num_labels=len(set(train_labels))
    )

    # Create datasets
    train_dataset = CustomDataset(train_texts, train_labels, tokenizer)
    val_dataset = CustomDataset(val_texts, val_labels, tokenizer)

    # Define training arguments
    training_args = TrainingArguments(
        output_dir='./results',
        num_train_epochs=3,
        per_device_train_batch_size=16,
        per_device_eval_batch_size=64,
        warmup_steps=500,
        weight_decay=0.01,
        logging_dir='./logs',
        logging_steps=10,
        evaluation_strategy="epoch",
        save_strategy="epoch",
        load_best_model_at_end=True,
        metric_for_best_model="f1"
    )

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

    # Train the model
    trainer.train()
    
    return model, tokenizer

# Example usage
train_texts = [
    "This product is amazing!",
    "Terrible service, would not recommend",
    "Neutral experience overall"
]
train_labels = [1, 0, 2]  # 1: positive, 0: negative, 2: neutral
val_texts = [
    "Great purchase, very satisfied",
    "Disappointing quality"
]
val_labels = [1, 0]

model, tokenizer = fine_tune_model(train_texts, train_labels, val_texts, val_labels)

Este ejemplo demuestra un proceso integral de ajuste fino que incorpora varios componentes esenciales para un entrenamiento óptimo del modelo:

Implementación de Conjunto de Datos Personalizado:
- Crea una clase de conjunto de datos especializada que maneja eficientemente tanto datos de texto como sus etiquetas correspondientes
- Implementa la interfaz Dataset de PyTorch para una integración fluida con los ciclos de entrenamiento
- Gestiona el procesamiento por lotes y la eficiencia de memoria
Cálculo Robusto de Métricas:
- Implementa métricas de evaluación completas incluyendo precisión, exactitud, recuperación y puntuación F1
- Permite el monitoreo en tiempo real del rendimiento del modelo durante el entrenamiento
- Facilita la comparación y selección de modelos
Configuración Avanzada de Entrenamiento con Mejores Prácticas de la Industria:
- Calentamiento de la Tasa de Aprendizaje: Aumenta gradualmente la tasa de aprendizaje durante los pasos iniciales de entrenamiento para prevenir gradientes inestables y asegurar una convergencia suave
- Decaimiento de Pesos: Implementa regularización L2 para prevenir el sobreajuste y mejorar la generalización del modelo
- Evaluación Estratégica: Realiza evaluaciones periódicas del modelo en datos de validación para seguir el progreso del entrenamiento
- Sistema de Puntos de Control: Guarda estados del modelo en intervalos regulares para permitir la recuperación y selección de parámetros óptimos
- Selección Inteligente de Modelo: Utiliza la puntuación F1 como la métrica principal para seleccionar la mejor versión del modelo durante el entrenamiento

Registro de Salida Esperado:

{'train_runtime': '2:34:15',
 'train_samples_per_second': 8.123,
 'train_steps_per_second': 0.508,
 'train_loss': 0.1234,
 'epoch': 3.0,
 'eval_loss': 0.2345,
 'eval_accuracy': 0.89,
 'eval_f1': 0.88,
 'eval_precision': 0.87,
 'eval_recall': 0.86}

5. Inferencia: Realizando Predicciones en el Mundo Real

La etapa de inferencia es donde tu modelo entrenado se pone en uso práctico realizando predicciones sobre datos de texto nuevos y no vistos. Este proceso involucra varios pasos críticos:

Preprocesar nuevos datos usando el mismo pipeline que los datos de entrenamiento:
- Aplicar pasos idénticos de limpieza y normalización de texto
- Usar el mismo enfoque de tokenización y vocabulario
- Asegurar un manejo consistente de caracteres especiales y formato
Generar predicciones con puntuaciones de confianza:
- Ejecutar el texto preprocesado a través del modelo
- Obtener distribuciones de probabilidad entre las clases posibles
- Aplicar criterios de umbral para la toma de decisiones
Post-procesar resultados para interpretación y uso:
- Convertir las salidas del modelo a formato legible por humanos
- Aplicar reglas de negocio o filtrado si es necesario
- Formatear resultados para integración con sistemas posteriores

Ejemplo: Pipeline Completo de Inferencia

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import numpy as np

class TextClassificationPipeline:
    def __init__(self, model_name='bert-base-uncased', device='cuda' if torch.cuda.is_available() else 'cpu'):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
        self.device = device
        self.model.to(device)
        self.model.eval()
        
    def preprocess(self, text):
        # Clean and normalize text
        text = text.lower().strip()
        
        # Tokenize
        encoded = self.tokenizer(
            text,
            truncation=True,
            padding=True,
            max_length=512,
            return_tensors='pt'
        )
        
        return {k: v.to(self.device) for k, v in encoded.items()}
    
    def predict(self, text, threshold=0.5):
        # Preprocess input
        inputs = self.preprocess(text)
        
        # Run inference
        with torch.no_grad():
            outputs = self.model(**inputs)
            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
        
        # Get predictions
        predictions = probabilities.cpu().numpy()
        
        # Post-process results
        result = {
            'label': self.model.config.id2label[predictions.argmax()],
            'confidence': float(predictions.max()),
            'all_probabilities': {
                self.model.config.id2label[i]: float(p)
                for i, p in enumerate(predictions[0])
            }
        }
        
        # Apply threshold if specified
        result['above_threshold'] = result['confidence'] >= threshold
        
        return result

def batch_inference(texts, pipeline, batch_size=32):
    results = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        batch_results = [pipeline.predict(text) for text in batch]
        results.extend(batch_results)
    return results

# Example usage
if __name__ == "__main__":
    # Initialize pipeline
    pipeline = TextClassificationPipeline()
    
    # Example texts
    texts = [
        "This product exceeded all my expectations!",
        "The customer service was absolutely horrible.",
        "The package arrived on time, as expected."
    ]
    
    # Single prediction
    print("Single Text Inference:")
    result = pipeline.predict(texts[0])
    print(f"Text: {texts[0]}")
    print(f"Prediction: {result}\n")
    
    # Batch prediction
    print("Batch Inference:")
    results = batch_inference(texts, pipeline)
    for text, result in zip(texts, results):
        print(f"Text: {text}")
        print(f"Prediction: {result}\n")

Aquí está el desglose de sus componentes principales:

Clase TextClassificationPipeline

Se inicializa con un modelo pre-entrenado (por defecto BERT) y gestiona la configuración del dispositivo (CPU/GPU)
Incluye preprocesamiento que normaliza el texto y maneja la tokenización con una longitud máxima de 512 tokens
Implementa funcionalidad de predicción con puntuación de confianza y filtrado basado en umbrales

Métodos Principales

preprocess(): Limpia el texto y lo convierte a un formato compatible con el modelo
predict(): Maneja la predicción de texto individual con una salida completa que incluye:
- Predicción de etiqueta
- Puntuación de confianza
- Distribución de probabilidad entre todas las clases posibles
batch_inference(): Procesa múltiples textos eficientemente en lotes de 32

Formato de Salida

Devuelve predicciones estructuradas con:
- Etiqueta predicha
- Puntuación de confianza
- Distribución completa de probabilidad
- Resultado de verificación de umbral

Salida Esperada:

Single Text Inference:
Text: This product exceeded all my expectations!
Prediction: {
    'label': 'POSITIVE',
    'confidence': 0.97,
    'all_probabilities': {
        'NEGATIVE': 0.01,
        'NEUTRAL': 0.02,
        'POSITIVE': 0.97
    },
    'above_threshold': True
}

Batch Inference:
Text: This product exceeded all my expectations!
Prediction: {
    'label': 'POSITIVE',
    'confidence': 0.97,
    'all_probabilities': {...}
    'above_threshold': True
}

Text: The customer service was absolutely horrible.
Prediction: {
    'label': 'NEGATIVE',
    'confidence': 0.95,
    'all_probabilities': {...}
    'above_threshold': True
}

Text: The package arrived on time, as expected.
Prediction: {
    'label': 'NEUTRAL',
    'confidence': 0.88,
    'all_probabilities': {...}
    'above_threshold': True
}

6.3.3 Aplicaciones de la Clasificación de Texto

1. Detección de Spam

Identifica y filtra correos electrónicos o mensajes no deseados utilizando algoritmos sofisticados de aprendizaje automático que aprovechan el procesamiento del lenguaje natural y el reconocimiento de patrones. Esto incluye un análisis exhaustivo de múltiples puntos de datos:

Análisis del contenido del mensaje: Examen de patrones de texto, frecuencias de palabras clave y características lingüísticas
Patrones de comportamiento del remitente: Evaluación de la frecuencia de envío, patrones temporales y reputación histórica del remitente
Metadatos técnicos: Análisis de encabezados de correo, direcciones IP, registros de autenticación e información de enrutamiento
Análisis de archivos adjuntos: Escaneo de tipos de archivo sospechosos y contenido malicioso

Los sistemas modernos de detección de spam emplean técnicas avanzadas para identificar varios tipos de comunicaciones no deseadas:

Intentos sofisticados de phishing utilizando ingeniería social
Campañas dirigidas de spear-phishing
Correos masivos de marketing que violan regulaciones
Intentos de distribución de malware
Estafas de compromiso de correo empresarial (BEC)

Estos sistemas aprenden y se adaptan continuamente a nuevas amenazas, ayudando a mantener la seguridad y organización del buzón mediante:

Detección y bloqueo de amenazas en tiempo real
Filtrado adaptativo basado en retroalimentación del usuario
Integración con redes globales de inteligencia de amenazas
Cuarentena y clasificación automatizada de mensajes sospechosos

Ejemplo: Sistema Integral de Detección de Spam

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import re
from typing import List, Dict
import numpy as np

class SpamDetectionSystem:
    def __init__(self, model_name: str = 'bert-base-uncased', threshold: float = 0.5):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
        self.threshold = threshold
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        self.model.to(self.device)
        
    def preprocess_text(self, text: str) -> str:
        """Clean and normalize text input"""
        # Convert to lowercase
        text = text.lower()
        # Remove URLs
        text = re.sub(r'http\S+|www\S+|https\S+', '', text)
        # Remove email addresses
        text = re.sub(r'\S+@\S+', '', text)
        # Remove special characters
        text = re.sub(r'[^\w\s]', '', text)
        # Remove extra whitespace
        text = ' '.join(text.split())
        return text
    
    def extract_features(self, text: str) -> Dict:
        """Extract additional spam-indicative features"""
        features = {
            'contains_urgent': bool(re.search(r'urgent|immediate|act now', text.lower())),
            'contains_money': bool(re.search(r'[$€£]\d+|\d+[$€£]|money|cash', text.lower())),
            'excessive_caps': len(re.findall(r'[A-Z]{3,}', text)) > 2,
            'text_length': len(text.split()),
        }
        return features
    
    def predict(self, text: str) -> Dict:
        """Perform spam detection on a single text"""
        # Preprocess text
        cleaned_text = self.preprocess_text(text)
        
        # Extract additional features
        features = self.extract_features(text)
        
        # Tokenize
        inputs = self.tokenizer(
            cleaned_text,
            truncation=True,
            padding=True,
            max_length=512,
            return_tensors='pt'
        ).to(self.device)
        
        # Get model prediction
        self.model.eval()
        with torch.no_grad():
            outputs = self.model(**inputs)
            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
            spam_probability = float(probabilities[0][1].cpu())
        
        # Combine model prediction with rule-based features
        final_score = spam_probability
        if features['contains_urgent'] and features['contains_money']:
            final_score += 0.1
        if features['excessive_caps']:
            final_score += 0.05
            
        return {
            'is_spam': final_score >= self.threshold,
            'spam_probability': final_score,
            'features': features,
            'original_text': text,
            'cleaned_text': cleaned_text
        }
    
    def batch_predict(self, texts: List[str], batch_size: int = 32) -> List[Dict]:
        """Process multiple texts in batches"""
        results = []
        for i in range(0, len(texts), batch_size):
            batch = texts[i:i + batch_size]
            batch_results = [self.predict(text) for text in batch]
            results.extend(batch_results)
        return results

# Example usage
if __name__ == "__main__":
    # Initialize spam detector
    spam_detector = SpamDetectionSystem()
    
    # Example messages
    messages = [
        "Hey! How are you doing?",
        "URGENT! You've won $10,000,000! Send bank details NOW!!!",
        "Meeting scheduled for tomorrow at 2 PM",
        "FREE VIAGRA! Best prices! Click here NOW!!!"
    ]
    
    # Process messages
    results = spam_detector.batch_predict(messages)
    
    # Display results
    for msg, result in zip(messages, results):
        print(f"\nMessage: {msg}")
        print(f"Spam Probability: {result['spam_probability']:.2f}")
        print(f"Is Spam: {result['is_spam']}")
        print(f"Features: {result['features']}")

Desglose del Código:

Componentes Principales:
- Modelo basado en Transformers para análisis profundo de texto
- Extracción de características basada en reglas para señales adicionales
- Pipeline integral de preprocesamiento de texto
- Capacidades de procesamiento por lotes para eficiencia
Características Clave:
- Enfoque híbrido que combina ML y detección basada en reglas
- Limpieza y normalización exhaustiva de texto
- Extracción adicional de indicadores de spam
- Umbral de spam configurable
Capacidades Avanzadas:
- Soporte de aceleración GPU para procesamiento más rápido
- Procesamiento por lotes para manejar múltiples mensajes
- Informes detallados de predicción con análisis de características
- Sistema de puntuación personalizable que combina múltiples señales

Esta implementación proporciona una base robusta para la detección de spam que puede extenderse con características adicionales como análisis de reputación del remitente, escaneo de enlaces y actualizaciones del modelo de aprendizaje automático basadas en la retroalimentación del usuario.

2. Análisis de Retroalimentación del Cliente

Procesar y categorizar automáticamente la retroalimentación del cliente a través de múltiples dimensiones incluyendo:

Evaluación de Calidad del Producto
- Evaluaciones de rendimiento y durabilidad
- Informes de consistencia de fabricación
- Retroalimentación de funcionalidad de características
Análisis de Precios
- Métricas de percepción de valor
- Comparaciones de precios competitivos
- Retroalimentación sobre la relación precio-características
Evaluación de Experiencia de Servicio
- Calidad de interacción del servicio al cliente
- Mediciones de tiempo de respuesta
- Efectividad en la resolución de problemas
Retroalimentación de Interfaz de Usuario
- Evaluaciones de usabilidad
- Informes de eficiencia de navegación
- Preferencias de diseño y disposición

Este análisis integral permite a las empresas:

Rastrear tendencias emergentes en tiempo real
Identificar áreas específicas que requieren atención inmediata
Priorizar mejoras basadas en el impacto al cliente
Asignar recursos más efectivamente
Desarrollar hojas de ruta de productos basadas en datos

Los sistemas avanzados mejoran este proceso a través de:

Detección Inteligente de Urgencia
- Algoritmos de análisis de sentimientos
- Mecanismos de puntuación de prioridad
- Métricas de evaluación de impacto
Sistemas de Enrutamiento Automatizado
- Asignación de problemas por departamento
- Protocolos de escalamiento
- Optimización de tiempo de respuesta

Ejemplo: Sistema de Análisis Multidimensional de Retroalimentación del Cliente

from transformers import pipeline
import pandas as pd
import numpy as np
from typing import List, Dict, Union
from collections import defaultdict

class CustomerFeedbackAnalyzer:
    def __init__(self):
        # Initialize various analysis pipelines
        self.sentiment_analyzer = pipeline("sentiment-analysis")
        self.zero_shot_classifier = pipeline("zero-shot-classification")
        self.aspect_categories = [
            "product_quality", "pricing", "customer_service",
            "user_interface", "features", "reliability"
        ]
        
    def analyze_feedback(self, text: str) -> Dict[str, Union[str, float, Dict]]:
        """Comprehensive analysis of a single feedback entry"""
        results = {}
        
        # Sentiment Analysis
        sentiment = self.sentiment_analyzer(text)[0]
        results['sentiment'] = {
            'label': sentiment['label'],
            'score': sentiment['score']
        }
        
        # Aspect-based categorization
        aspect_results = self.zero_shot_classifier(
            text,
            candidate_labels=self.aspect_categories,
            multi_label=True
        )
        
        # Filter aspects with confidence > 0.3
        results['aspects'] = {
            label: score for label, score in 
            zip(aspect_results['labels'], aspect_results['scores'])
            if score > 0.3
        }
        
        # Extract key metrics
        results['metrics'] = self._extract_metrics(text)
        
        # Priority scoring
        results['priority_score'] = self._calculate_priority(
            results['sentiment'],
            results['aspects']
        )
        
        return results
    
    def _extract_metrics(self, text: str) -> Dict[str, Union[int, float]]:
        """Extract numerical metrics from feedback"""
        metrics = {
            'word_count': len(text.split()),
            'avg_word_length': np.mean([len(word) for word in text.split()]),
            'contains_rating': bool(re.search(r'\d+/\d+|\d+\s*stars?', text.lower()))
        }
        return metrics
    
    def _calculate_priority(self, sentiment: Dict, aspects: Dict) -> float:
        """Calculate priority score based on sentiment and aspects"""
        # Base priority on sentiment
        priority = 0.5  # Default medium priority
        
        # Adjust based on sentiment
        if sentiment['label'] == 'NEGATIVE' and sentiment['score'] > 0.8:
            priority += 0.3
        
        # Adjust based on critical aspects
        critical_aspects = {'customer_service', 'reliability', 'product_quality'}
        for aspect, score in aspects.items():
            if aspect in critical_aspects and score > 0.7:
                priority += 0.1
        
        return min(1.0, priority)  # Cap at 1.0
    
    def batch_analyze(self, feedback_list: List[str]) -> List[Dict]:
        """Process multiple feedback entries"""
        return [self.analyze_feedback(text) for text in feedback_list]
    
    def generate_summary_report(self, feedback_results: List[Dict]) -> Dict:
        """Generate summary statistics from analyzed feedback"""
        summary = {
            'total_feedback': len(feedback_results),
            'sentiment_distribution': defaultdict(int),
            'aspect_frequency': defaultdict(int),
            'priority_levels': {
                'high': 0,
                'medium': 0,
                'low': 0
            }
        }
        
        for result in feedback_results:
            # Count sentiments
            summary['sentiment_distribution'][result['sentiment']['label']] += 1
            
            # Count aspects
            for aspect in result['aspects'].keys():
                summary['aspect_frequency'][aspect] += 1
            
            # Categorize priority
            priority = result['priority_score']
            if priority > 0.7:
                summary['priority_levels']['high'] += 1
            elif priority > 0.3:
                summary['priority_levels']['medium'] += 1
            else:
                summary['priority_levels']['low'] += 1
        
        return summary

# Example usage
if __name__ == "__main__":
    analyzer = CustomerFeedbackAnalyzer()
    
    # Example feedback entries
    feedback_examples = [
        "The new interface is amazing! So much easier to use than before.",
        "Product quality has declined significantly. Customer service was unhelpful.",
        "Decent product but a bit pricey for what you get.",
        "System keeps crashing. This is extremely frustrating!"
    ]
    
    # Analyze feedback
    results = analyzer.batch_analyze(feedback_examples)
    
    # Generate summary report
    summary = analyzer.generate_summary_report(results)
    
    # Print detailed analysis for first feedback
    print("\nDetailed Analysis of First Feedback:")
    print(f"Text: {feedback_examples[0]}")
    print(f"Sentiment: {results[0]['sentiment']}")
    print(f"Aspects: {results[0]['aspects']}")
    print(f"Priority Score: {results[0]['priority_score']}")
    
    # Print summary statistics
    print("\nSummary Report:")
    print(f"Total Feedback Analyzed: {summary['total_feedback']}")
    print(f"Sentiment Distribution: {dict(summary['sentiment_distribution'])}")
    print(f"Priority Levels: {summary['priority_levels']}")

Desglose del Código:

Componentes Principales:
- Múltiples canales de análisis para diferentes aspectos de la retroalimentación
- Análisis integral de retroalimentación que abarca sentimiento, aspectos y métricas
- Sistema de puntuación de prioridad para clasificación de retroalimentación
- Capacidades de procesamiento por lotes para mayor eficiencia
Características Clave:
- Análisis multidimensional que incorpora clasificación basada en sentimientos y aspectos
- Categorización flexible de aspectos utilizando clasificación de tipo zero-shot
- Extracción de métricas para análisis cuantitativo
- Puntuación de prioridad basada en múltiples factores
Capacidades Avanzadas:
- Análisis detallado de retroalimentación individual
- Procesamiento por lotes para múltiples entradas de retroalimentación
- Generación de informes resumidos con estadísticas clave
- Categorías de aspectos y puntuación de prioridad personalizables

Esta implementación proporciona una base sólida para analizar la retroalimentación del cliente, permitiendo a las empresas:

Identificar tendencias y patrones en el sentimiento del cliente
Priorizar problemas urgentes que requieren atención inmediata
Realizar seguimiento del rendimiento en diferentes aspectos de productos/servicios
Generar conclusiones accionables a partir de datos de retroalimentación del cliente

3. Categorización de Temas

Clasificar automáticamente el contenido en categorías o temas predefinidos utilizando comprensión contextual y técnicas avanzadas de procesamiento del lenguaje natural. Este sofisticado proceso involucra:

Análisis Semántico
- Comprensión del significado profundo del texto más allá de las palabras clave
- Reconocimiento de relaciones entre conceptos
- Identificación de patrones temáticos entre documentos
Métodos de Clasificación
- Categorización jerárquica para temas anidados
- Clasificación multi-etiqueta para contenido que abarca múltiples categorías
- Adaptación dinámica de categorías basada en tendencias emergentes

Este enfoque sistemático ayuda a organizar grandes colecciones de documentos, permite un descubrimiento eficiente de contenido y apoya los sistemas de recomendación de contenido. La tecnología encuentra diversas aplicaciones en múltiples sectores:

Publicación Académica
- Clasificación de trabajos de investigación por campo y subcampo
- Etiquetado automático de artículos científicos
Medios y Publicación
- Categorización de noticias en tiempo real
- Curación de contenido para plataformas digitales
Plataformas en Línea
- Moderación de contenido generado por usuarios
- Organización automatizada de contenido

from transformers import pipeline
from sklearn.preprocessing import MultiLabelBinarizer
from typing import List, Dict, Union
import numpy as np
from collections import defaultdict

class TopicCategorizer:
    def __init__(self, threshold: float = 0.3):
        # Initialize zero-shot classification pipeline
        self.classifier = pipeline("zero-shot-classification")
        self.threshold = threshold
        
        # Define hierarchical topic structure
        self.topic_hierarchy = {
            "technology": ["software", "hardware", "ai", "cybersecurity"],
            "business": ["finance", "marketing", "management", "startups"],
            "science": ["physics", "biology", "chemistry", "astronomy"],
            "health": ["medicine", "nutrition", "fitness", "mental_health"]
        }
        
        # Flatten topics for initial classification
        self.main_topics = list(self.topic_hierarchy.keys())
        self.all_subtopics = [
            subtopic for subtopics in self.topic_hierarchy.values()
            for subtopic in subtopics
        ]
        
    def categorize_text(self, text: str) -> Dict[str, Union[List[str], float]]:
        """Perform hierarchical topic categorization on input text"""
        results = {}
        
        # First level: Main topic classification
        main_topic_results = self.classifier(
            text,
            candidate_labels=self.main_topics,
            multi_label=True
        )
        
        # Filter main topics above threshold
        relevant_main_topics = [
            label for label, score in 
            zip(main_topic_results['labels'], main_topic_results['scores'])
            if score > self.threshold
        ]
        
        # Second level: Subtopic classification for relevant main topics
        relevant_subtopics = []
        for main_topic in relevant_main_topics:
            subtopic_candidates = self.topic_hierarchy[main_topic]
            subtopic_results = self.classifier(
                text,
                candidate_labels=subtopic_candidates,
                multi_label=True
            )
            
            # Filter subtopics above threshold
            relevant_subtopics.extend([
                label for label, score in 
                zip(subtopic_results['labels'], subtopic_results['scores'])
                if score > self.threshold
            ])
        
        results['main_topics'] = relevant_main_topics
        results['subtopics'] = relevant_subtopics
        
        # Calculate confidence scores
        results['confidence_scores'] = {
            'main_topics': {
                label: score for label, score in 
                zip(main_topic_results['labels'], main_topic_results['scores'])
                if score > self.threshold
            },
            'subtopics': {
                label: score for label, score in 
                zip(subtopic_results['labels'], subtopic_results['scores'])
                if score > self.threshold
            }
        }
        
        return results
    
    def batch_categorize(self, texts: List[str]) -> List[Dict]:
        """Process multiple texts for categorization"""
        return [self.categorize_text(text) for text in texts]
    
    def generate_topic_report(self, results: List[Dict]) -> Dict:
        """Generate summary statistics from categorization results"""
        report = {
            'total_documents': len(results),
            'main_topic_distribution': defaultdict(int),
            'subtopic_distribution': defaultdict(int),
            'average_confidence': {
                'main_topics': defaultdict(list),
                'subtopics': defaultdict(list)
            }
        }
        
        for result in results:
            # Count topic occurrences
            for topic in result['main_topics']:
                report['main_topic_distribution'][topic] += 1
                
            for subtopic in result['subtopics']:
                report['subtopic_distribution'][subtopic] += 1
            
            # Collect confidence scores
            for topic, score in result['confidence_scores']['main_topics'].items():
                report['average_confidence']['main_topics'][topic].append(score)
                
            for topic, score in result['confidence_scores']['subtopics'].items():
                report['average_confidence']['subtopics'][topic].append(score)
        
        # Calculate average confidence scores
        for topic_level in ['main_topics', 'subtopics']:
            for topic, scores in report['average_confidence'][topic_level].items():
                report['average_confidence'][topic_level][topic] = \
                    np.mean(scores) if scores else 0.0
        
        return report

# Example usage
if __name__ == "__main__":
    categorizer = TopicCategorizer()
    
    # Example texts
    example_texts = [
        "New research shows quantum computers achieving unprecedented processing speeds.",
        "Start-up raises $50M for innovative AI-powered healthcare solutions.",
        "Scientists discover new exoplanet in habitable zone of nearby star."
    ]
    
    # Categorize texts
    results = categorizer.batch_categorize(example_texts)
    
    # Generate summary report
    report = categorizer.generate_topic_report(results)
    
    # Print example results
    print("\nExample Categorization Results:")
    for i, (text, result) in enumerate(zip(example_texts, results)):
        print(f"\nText {i+1}: {text}")
        print(f"Main Topics: {result['main_topics']}")
        print(f"Subtopics: {result['subtopics']}")
        print(f"Confidence Scores: {result['confidence_scores']}")
    
    # Print summary statistics
    print("\nTopic Distribution Summary:")
    print(f"Main Topics: {dict(report['main_topic_distribution'])}")
    print(f"Subtopics: {dict(report['subtopic_distribution'])}")

Desglose del Código:

Componentes Principales:
- Pipeline de clasificación zero-shot para categorización flexible de temas
- Estructura jerárquica de temas que soporta temas principales y subtemas
- Sistema de puntuación de confianza para la asignación de temas
- Capacidades de procesamiento por lotes para múltiples documentos
Características Clave:
- Enfoque de clasificación jerárquica de dos niveles
- Umbral de confianza configurable para la asignación de temas
- Puntuación detallada de confianza tanto para temas principales como subtemas
- Capacidades completas de informes y análisis
Capacidades Avanzadas:
- Clasificación multi-etiqueta que admite asignaciones de múltiples temas
- Jerarquía de temas flexible que puede modificarse fácilmente
- Métricas de rendimiento detalladas y puntuación de confianza
- Procesamiento por lotes escalable para grandes colecciones de documentos

Esta implementación proporciona una base sólida para la categorización de temas, permitiendo:

Organización automática de grandes colecciones de documentos
Sistemas de descubrimiento y recomendación de contenido
Análisis de tendencias en diferentes áreas temáticas
Evaluación de calidad de las asignaciones de temas mediante puntuaciones de confianza

4. Análisis de Sentimientos

Analizar texto para determinar el tono emocional y la actitud expresada por los clientes sobre productos, servicios o marcas. Este análisis sofisticado involucra múltiples capas de comprensión:

Análisis Emocional
- Detección básica de sentimientos (positivo/negativo/neutral)
- Reconocimiento de emociones complejas (alegría, enojo, frustración, entusiasmo)
- Medición de la intensidad de las emociones expresadas
Comprensión Contextual
- Detección de sarcasmo e ironía
- Reconocimiento de sentimientos implícitos
- Comprensión de terminología específica de la industria

Las empresas aprovechan esta profunda perspectiva emocional para múltiples propósitos estratégicos:

Monitoreo de Marca
- Seguimiento en tiempo real de la percepción de marca
- Análisis competitivo
- Detección y gestión de crisis
Desarrollo de Productos
- Priorización de características basada en sentimientos
- Optimización de la experiencia del usuario
- Oportunidades de mejora del producto
Mejora del Servicio al Cliente
- Identificación proactiva de problemas
- Medición de la calidad del servicio
- Seguimiento de la satisfacción del cliente

5. Reconocimiento de Intención

Procesar y comprender las consultas de los usuarios para determinar su propósito o meta subyacente. Esta capacidad crítica permite a los asistentes de IA y chatbots proporcionar respuestas relevantes y tomar acciones apropiadas basadas en las necesidades del usuario. Los sistemas de reconocimiento de intención emplean procesamiento sofisticado del lenguaje natural para:

Identificar Intenciones Principales
- Reconocer objetivos principales del usuario (por ejemplo, realizar una compra, buscar información, solicitar soporte)
- Distinguir entre intenciones informativas, transaccionales y de navegación
- Mapear consultas a categorías predefinidas de intención
Manejar la Complejidad de las Consultas
- Procesar solicitudes compuestas con múltiples intenciones integradas
- Comprender intenciones implícitas a partir de pistas contextuales
- Resolver solicitudes ambiguas o poco claras del usuario

Los sistemas avanzados de reconocimiento de intención incorporan conciencia contextual y capacidades de aprendizaje para:

Mantener el Contexto de la Conversación
- Rastrear el historial de conversación para una mejor comprensión
- Considerar las preferencias del usuario e interacciones pasadas
- Adaptar respuestas basadas en el contexto situacional

Estas capacidades sofisticadas permiten interacciones más naturales y similares a las humanas al interpretar con precisión las necesidades del usuario y proporcionar respuestas apropiadas, incluso en escenarios conversacionales complejos.

from transformers import pipeline
from typing import List, Dict, Tuple, Optional
import numpy as np
from dataclasses import dataclass
from collections import defaultdict

@dataclass
class Intent:
    name: str
    confidence: float
    entities: Dict[str, str]

class IntentRecognizer:
    def __init__(self, confidence_threshold: float = 0.6):
        # Initialize zero-shot classification pipeline
        self.classifier = pipeline("zero-shot-classification")
        self.confidence_threshold = confidence_threshold
        
        # Define intent categories and their associated patterns
        self.intent_categories = {
            "purchase": ["buy", "purchase", "order", "get", "acquire"],
            "information": ["what is", "how to", "explain", "tell me about"],
            "support": ["help", "issue", "problem", "not working", "broken"],
            "comparison": ["compare", "difference between", "better than"],
            "availability": ["in stock", "available", "when can I"]
        }
        
        # Entity extraction pipeline
        self.ner_pipeline = pipeline("ner")
        
    def preprocess_text(self, text: str) -> str:
        """Clean and normalize input text"""
        return text.lower().strip()
    
    def extract_entities(self, text: str) -> Dict[str, str]:
        """Extract named entities from text"""
        entities = self.ner_pipeline(text)
        return {
            entity['entity_group']: entity['word']
            for entity in entities
        }
    
    def detect_intent(self, text: str) -> Optional[Intent]:
        """Identify primary intent from user query"""
        processed_text = self.preprocess_text(text)
        
        # Classify intent using zero-shot classification
        result = self.classifier(
            processed_text,
            candidate_labels=list(self.intent_categories.keys()),
            multi_label=False
        )
        
        # Get highest confidence intent
        primary_intent = result['labels'][0]
        confidence = result['scores'][0]
        
        if confidence >= self.confidence_threshold:
            # Extract relevant entities
            entities = self.extract_entities(text)
            
            return Intent(
                name=primary_intent,
                confidence=confidence,
                entities=entities
            )
        return None
    
    def handle_compound_intents(self, text: str) -> List[Intent]:
        """Process text for multiple potential intents"""
        sentences = text.split('.')
        intents = []
        
        for sentence in sentences:
            if sentence.strip():
                intent = self.detect_intent(sentence)
                if intent:
                    intents.append(intent)
        
        return intents
    
    def generate_response(self, intent: Intent) -> str:
        """Generate appropriate response based on detected intent"""
        responses = {
            "purchase": "I can help you make a purchase. ",
            "information": "Let me provide you with information about that. ",
            "support": "I'll help you resolve this issue. ",
            "comparison": "I can help you compare these options. ",
            "availability": "Let me check the availability for you. "
        }
        
        base_response = responses.get(intent.name, "I understand your request. ")
        
        # Add entity-specific information if available
        if intent.entities:
            entity_str = ", ".join(f"{k}: {v}" for k, v in intent.entities.items())
            base_response += f"I see you're interested in: {entity_str}"
        
        return base_response

# Example usage
if __name__ == "__main__":
    recognizer = IntentRecognizer()
    
    # Test cases
    test_queries = [
        "I want to buy a new laptop",
        "Can you explain how cloud computing works?",
        "I'm having problems with my account login",
        "What's the difference between Python and JavaScript?",
        "When will the new iPhone be available?"
    ]
    
    for query in test_queries:
        print(f"\nQuery: {query}")
        intent = recognizer.detect_intent(query)
        if intent:
            print(f"Detected Intent: {intent.name}")
            print(f"Confidence: {intent.confidence:.2f}")
            print(f"Entities: {intent.entities}")
            print(f"Response: {recognizer.generate_response(intent)}")

Desglose del Código:

Componentes Principales:
- Pipeline de clasificación sin ejemplos para reconocimiento flexible de intención
- Pipeline de Reconocimiento de Entidades Nombradas (NER) para extracción de entidades
- Categorías de intención con patrones asociados
- Sistema de generación de respuestas basado en intenciones detectadas
Características Clave:
- Umbral de confianza configurable para detección de intenciones
- Soporte para procesamiento de intenciones compuestas
- Extracción de entidades e integración en respuestas
- Sistema integral de clasificación de intenciones
Capacidades Avanzadas:
- Detección de múltiples intenciones en consultas complejas
- Generación de respuestas contextual
- Personalización de respuestas basada en entidades
- Gestión flexible de categorías de intención

Esta implementación proporciona una base robusta para sistemas de reconocimiento de intención, permitiendo:

Comprensión del lenguaje natural en IA conversacional
Generación automatizada de respuestas de servicio al cliente
Enrutamiento inteligente de consultas de usuarios a los manejadores apropiados
Generación contextual de respuestas basada en intenciones y entidades detectadas

6.3.4 Desafíos en la Clasificación de Texto

Desequilibrio de Clases

Los conjuntos de datos con distribuciones desequilibradas de clases representan un desafío significativo en la clasificación de texto que puede impactar severamente el rendimiento del modelo. Esto ocurre cuando los datos de entrenamiento tienen una representación desproporcionada de diferentes clases, donde algunas clases (clases mayoritarias) tienen sustancialmente más ejemplos que otras (clases minoritarias). Este desequilibrio crea varios problemas críticos:

Sobreajuste a clases mayoritarias
- Los modelos se vuelven sesgados hacia la predicción de la clase mayoritaria, incluso cuando la evidencia sugiere lo contrario
- Las características aprendidas reflejan principalmente patrones en la clase dominante
- Los límites de clasificación se sesgan hacia características de la clase mayoritaria
Pobre reconocimiento de características de clases minoritarias
- La exposición limitada a ejemplos de clases minoritarias resulta en un aprendizaje débil de características
- Los modelos luchan por identificar patrones distintivos en clases subrepresentadas
- Mayores tasas de clasificación errónea para instancias de clases minoritarias
Probabilidades de predicción sesgadas
- Los puntajes de confianza se vuelven poco fiables debido al sesgo en la distribución de clases
- Los modelos tienden a asignar probabilidades más altas a las clases mayoritarias por defecto
- La toma de decisiones basada en umbrales se vuelve menos efectiva

Para abordar estos desafíos, los profesionales emplean varias soluciones probadas:

Enfoques a nivel de datos:
- Sobremuestreo de clases minoritarias usando técnicas como SMOTE (Técnica de Sobremuestreo de Minorías Sintéticas)
- Submuestreo de clases mayoritarias preservando ejemplos importantes
- Enfoques híbridos combinando tanto sobre como submuestreo
Soluciones a nivel de algoritmo:
- Implementación de funciones de pérdida ponderadas por clase para penalizar más fuertemente los errores de clases minoritarias
- Uso de métodos de conjunto diseñados específicamente para conjuntos de datos desequilibrados
- Aplicación de enfoques de aprendizaje sensibles al costo

Vocabulario Específico del Dominio

Los Transformers a menudo requieren enfoques de entrenamiento especializados para manejar efectivamente vocabularios y terminología específicos del dominio. Este desafío significativo requiere consideración cuidadosa e implementación de estrategias de entrenamiento adicionales:

Campos técnicos con terminología única
- Terminología médica y jerga - Incluyendo términos anatómicos complejos, nombres de enfermedades, nomenclatura de medicamentos y terminología de procedimientos que raramente aparece en conjuntos de datos de lenguaje general
- Vocabulario científico - Términos especializados de física, química y otras ciencias que tienen significados técnicos precisos
- Terminología legal - Frases y términos legales específicos que tienen significados legales precisos
Desafíos Comunes de Vocabulario
- Palabras fuera del vocabulario (OOV) que no aparecen en los datos de entrenamiento inicial del modelo
- Significados específicos del contexto de palabras comunes cuando se usan en entornos técnicos
- Acrónimos y abreviaturas específicas de la industria que pueden tener múltiples interpretaciones

Para abordar estos desafíos de vocabulario, se pueden emplear varias técnicas especializadas:

Enfoques de Solución
- Adaptación de dominio mediante pre-entrenamiento continuo en corpus específicos del campo
- Estrategias de tokenización personalizadas que manejan mejor términos técnicos
- Aumento de vocabulario especializado durante el ajuste fino
- Integración de bases de conocimiento y ontologías específicas del dominio

Estas técnicas, cuando se implementan adecuadamente, pueden mejorar significativamente la capacidad del modelo para comprender y procesar contenido especializado mientras mantiene sus capacidades de lenguaje general.

6.3.5 Puntos Clave

La clasificación de texto es una tarea versátil de PLN con amplias aplicaciones en diferentes industrias. En servicio al cliente, ayuda a categorizar y enrutar tickets de soporte de manera eficiente. En moderación de contenido, identifica contenido inapropiado y spam. Para organizaciones de medios, permite la categorización automática de noticias y etiquetado de contenido. Las instituciones financieras la utilizan para análisis de sentimiento de informes de mercado y clasificación automatizada de documentos.
Los Transformers como BERT y RoBERTa han revolucionado la clasificación de texto a través de su arquitectura sofisticada. Su mecanismo de auto-atención les permite capturar dependencias de largo alcance en el texto, mientras que su procesamiento bidireccional asegura una comprensión integral del contexto. El pre-entrenamiento en corpus masivos de texto permite que estos modelos aprendan representaciones ricas del lenguaje, que luego pueden aplicarse efectivamente a tareas específicas de clasificación.
El ajuste fino en conjuntos de datos específicos del dominio es crucial para optimizar el rendimiento del transformer. Este proceso implica adaptar cuidadosamente el modelo pre-entrenado para comprender la terminología, convenciones y matices específicos de la industria. Por ejemplo, un clasificador de texto médico necesita reconocer terminología especializada, mientras que un clasificador de documentos legales debe comprender lenguaje legal complejo. Esta adaptabilidad hace que los transformers sean adecuados para diversas aplicaciones, desde la clasificación de artículos científicos hasta el análisis de contenido en redes sociales.
La implementación y despliegue exitosos de sistemas de clasificación de texto requieren una atención meticulosa a varios factores. La calidad del conjunto de datos debe garantizarse mediante una cuidadosa curación y limpieza de los datos de entrenamiento. Los pasos de preprocesamiento, como la normalización de texto y tokenización, deben optimizarse para el caso de uso específico. La evaluación del modelo debe incluir métricas integrales más allá de la precisión, como la precisión, recuperación y puntuación F1, particularmente para conjuntos de datos desequilibrados. El monitoreo y las actualizaciones regulares son esenciales para mantener el rendimiento a lo largo del tiempo.

6.3 Clasificación de Texto

Las aplicaciones de la clasificación de texto abarcan diversos campos y casos de uso, incluyendo:

Detección de Spam: Más allá de la simple categorización "spam" o "no spam", los sistemas modernos analizan múltiples aspectos de los correos electrónicos, incluyendo patrones de contenido, reputación del remitente y señales contextuales para proteger a los usuarios de comunicaciones no deseadas o maliciosas.
Clasificación por Temas: Los sistemas avanzados ahora pueden categorizar contenido a través de cientos de temas y subtemas, permitiendo una organización precisa del contenido en agregadores de noticias, sistemas de gestión de contenido y bases de datos de investigación. Los ejemplos se extienden más allá de deportes y política para incluir temas técnicos, disciplinas académicas y temas emergentes.
Análisis de Sentimiento: El análisis de sentimiento moderno va más allá de las clasificaciones básicas positivo/negativo/neutral para detectar matices emocionales sutiles, sarcasmo y opiniones dependientes del contexto. Esto permite a las empresas obtener percepciones más profundas sobre el feedback de los clientes y las reacciones en redes sociales.
Reconocimiento de Intención: Los sistemas contemporáneos de reconocimiento de intención pueden identificar intenciones complejas del usuario en IA conversacional, incluyendo solicitudes de múltiples pasos, intenciones implícitas y consultas dependientes del contexto. Esta capacidad es crucial para crear interacciones humano-computadora más naturales y efectivas.

6.3.1 ¿Por qué usar Transformers para la clasificación de texto?

Los Transformers han revolucionado la clasificación de texto al ofrecer varias ventajas revolucionarias:

Comprensión Contextual

Captar el significado matizado de las palabras basándose en su contexto circundante - Por ejemplo, entender que "banco" significa una institución financiera cuando se usa cerca de palabras como "dinero" o "cuenta", pero significa la orilla de un río cuando se usa cerca de palabras como "río" o "corriente"
Comprender dependencias de largo alcance entre oraciones - El modelo puede conectar conceptos relacionados incluso cuando aparecen separados por varias oraciones, de manera similar a cómo los humanos mantienen el contexto durante una conversación
Reconocer patrones lingüísticos sutiles y modismos - En lugar de tomar las frases literalmente, los Transformers pueden entender el lenguaje figurado y expresiones comunes analizando cómo estas frases se utilizan típicamente en contexto
Manejar la ambigüedad considerando el contexto completo de uso - Cuando se encuentran con palabras o frases que podrían tener múltiples significados, el modelo evalúa todo el contexto para determinar la interpretación más apropiada, similar a cómo los humanos resuelven la ambigüedad en la conversación natural

Aprendizaje por Transferencia

Reduce la necesidad de grandes conjuntos de datos de entrenamiento específicos para cada tarea
- Los enfoques tradicionales de aprendizaje automático a menudo requerían decenas de miles de ejemplos etiquetados
- El aprendizaje por transferencia puede lograr excelentes resultados con solo cientos de ejemplos
- Particularmente valioso para dominios especializados donde los datos etiquetados son escasos
Preserva la comprensión general del lenguaje mientras se adapta a dominios específicos
- Mantiene un amplio conocimiento de patrones y estructuras del lenguaje
- Se adapta exitosamente a terminología y convenciones específicas del dominio
- Equilibra efectivamente el conocimiento general y especializado
Permite una implementación rápida para nuevos casos de uso
- Reduce significativamente el tiempo de desarrollo comparado con el entrenamiento desde cero
- Permite una adaptación rápida a requisitos emergentes
- Facilita la mejora iterativa y la experimentación
Logra un rendimiento estado del arte con un entrenamiento específico mínimo
- A menudo supera a los modelos tradicionales entrenados desde cero
- Requiere menos tiempo de ajuste fino y recursos computacionales
- Demuestra una generalización superior a nuevos ejemplos

Versatilidad

Salud: Procesamiento de registros médicos y artículos de investigación, incluyendo terminología compleja, diagnósticos, protocolos de tratamiento y datos de ensayos clínicos. Estos modelos pueden identificar entidades médicas clave y relaciones mientras mantienen los estándares de privacidad del paciente.
Finanzas: Análisis de informes de mercado y documentos financieros, desde informes trimestrales de ganancias hasta evaluaciones de riesgo. Pueden procesar terminología financiera compleja, datos numéricos y requisitos de cumplimiento regulatorio mientras comprenden el contexto específico del mercado.
Servicio al Cliente: Comprensión de consultas y retroalimentación de clientes a través de múltiples canales, incluyendo correos electrónicos, registros de chat y redes sociales. Pueden detectar el sentimiento del cliente, la urgencia y la intención mientras manejan múltiples idiomas y estilos de comunicación.
Legal: Procesamiento de documentos legales y jurisprudencia, incluyendo contratos, patentes y decisiones judiciales. Estos modelos pueden comprender terminología legal compleja, precedentes y variaciones jurisdiccionales mientras mantienen la precisión en interpretaciones legales sensibles.

6.3.2 Pasos para la Clasificación de Texto con Transformers

1. Preparación de Datos

Limpieza y Estandarización

Eliminar caracteres irrelevantes, símbolos especiales y espacios en blanco innecesarios
- Eliminar etiquetas HTML y artefactos de formato
- Eliminar o reemplazar caracteres no imprimibles
- Estandarizar caracteres Unicode y codificaciones
Manejar valores faltantes e inconsistencias en el texto
- Identificar y manejar valores NULL apropiadamente
- Tratar con entradas de texto truncadas o corruptas
- Estandarizar patrones de formato inconsistentes
Normalizar texto (ej., minúsculas, eliminar acentos)
- Convertir todo el texto a un formato consistente (típicamente minúsculas)
- Eliminar o estandarizar marcas diacríticas
- Estandarizar puntuación y espaciado
Dividir datos en conjuntos de entrenamiento, validación y prueba
- Típicamente usar 70-80% para entrenamiento
- 10-15% para validación durante el desarrollo del modelo
- 10-15% para pruebas finales y evaluación
- Asegurar una distribución equilibrada de clases entre las divisiones

Ejemplo: Pipeline de Preparación de Datos

import pandas as pd
import re
from sklearn.model_selection import train_test_split

def clean_text(text):
    # Remove HTML tags
    text = re.sub(r'<[^>]+>', '', text)
    
    # Remove special characters and digits
    text = re.sub(r'[^a-zA-Z\s]', '', text)
    
    # Convert to lowercase
    text = text.lower()
    
    # Remove extra whitespace
    text = ' '.join(text.split())
    
    return text

# Load raw data
df = pd.read_csv('raw_data.csv')

# Clean text data
df['cleaned_text'] = df['text'].apply(clean_text)

# Split data while maintaining class distribution
train_data, temp_data = train_test_split(
    df, 
    test_size=0.3,
    stratify=df['label'],
    random_state=42
)

# Split temp data into validation and test sets
val_data, test_data = train_test_split(
    temp_data,
    test_size=0.5,
    stratify=temp_data['label'],
    random_state=42
)

print(f"Training samples: {len(train_data)}")
print(f"Validation samples: {len(val_data)}")
print(f"Test samples: {len(test_data)}")

Aquí está el desglose de sus componentes principales:

Importaciones y Configuración

Utiliza pandas para el manejo de datos, re para expresiones regulares y sklearn para la división de datos

Función de Limpieza de Texto

La función clean_text() realiza varios pasos de preprocesamiento:

Elimina etiquetas HTML
Elimina caracteres especiales y dígitos
Convierte el texto a minúsculas
Elimina espacios en blanco extra

Carga y Limpieza de Datos

Carga datos desde un archivo CSV
Aplica la función de limpieza a la columna de texto

División de Datos

El código implementa una división en dos etapas de los datos:

Primera división: 70% entrenamiento, 30% datos temporales
Segunda división: Los datos temporales se dividen equitativamente entre conjuntos de validación y prueba
Utiliza estratificación para mantener la distribución de clases en todas las divisiones

Resultados

La distribución final del conjunto de datos:

Conjunto de entrenamiento: 7,000 muestras
Conjunto de validación: 1,500 muestras
Conjunto de prueba: 1,500 muestras

Esta división sigue la práctica recomendada de usar 70-80% para entrenamiento y 10-15% cada uno para validación y pruebas.

Salida Esperada:

Training samples: 7000
Validation samples: 1500
Test samples: 1500

2. Selección del Modelo: Consideraciones Clave

La elección de un modelo Transformer pre-entrenado apropiado requiere una evaluación cuidadosa de varios factores críticos:

Considerar factores como el tamaño del modelo, requisitos computacionales y soporte de idiomas:
- El tamaño del modelo afecta el uso de memoria y la velocidad de inferencia
- Los requisitos de GPU/CPU impactan los costos de implementación
- El soporte de idiomas determina las capacidades multilingües
Las opciones populares incluyen:
- BERT: Excelente para tareas de clasificación de propósito general
- RoBERTa: Versión mejorada de BERT con entrenamiento optimizado
- DistilBERT: Variante más ligera y rápida, ideal para restricciones de recursos
- XLNet: Modelo avanzado mejor en el manejo de dependencias de largo alcance
Evaluar el equilibrio entre la complejidad del modelo y las necesidades de rendimiento:
- Los modelos más grandes generalmente ofrecen mejor precisión pero inferencia más lenta
- Los modelos más pequeños proporcionan procesamiento más rápido pero pueden sacrificar algo de precisión
- Considerar los requisitos y restricciones específicos de tu caso de uso

Ejemplo: Guía de Selección de Modelo

from transformers import AutoModelForSequenceClassification, AutoTokenizer

def select_model(task_requirements):
    if task_requirements['computational_resources'] == 'limited':
        # Lightweight model for resource-constrained environments
        model_name = "distilbert-base-uncased"
        max_length = 256
    elif task_requirements['language'] == 'multilingual':
        # Multilingual model for cross-language tasks
        model_name = "xlm-roberta-base"
        max_length = 512
    else:
        # Full-size model for maximum accuracy
        model_name = "roberta-large"
        max_length = 512
    
    # Load model and tokenizer
    model = AutoModelForSequenceClassification.from_pretrained(model_name)
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    
    return model, tokenizer, max_length

# Example usage
requirements = {
    'computational_resources': 'limited',
    'language': 'english',
    'task': 'sentiment_analysis'
}

model, tokenizer, max_length = select_model(requirements)
print(f"Selected model: {model.config.model_type}")
print(f"Model parameters: {model.num_parameters():,}")
print(f"Maximum sequence length: {max_length}")

Aquí está el desglose de sus componentes principales:

Definición de la Función:

La función select_model elige un modelo pre-entrenado apropiado basado en requisitos específicos de la tarea:

Para recursos computacionales limitados: Utiliza DistilBERT (un modelo ligero) con longitud de secuencia de 256
Para tareas multilingües: Utiliza XLM-RoBERTa con longitud de secuencia de 512
Para máxima precisión: Utiliza RoBERTa-large con longitud de secuencia de 512

Lógica de Selección del Modelo:

La función considera tres factores principales:

Tamaño del modelo y uso de memoria
Requisitos de GPU/CPU
Capacidades de soporte de idiomas

Ejemplo de Implementación:

El código incluye un ejemplo práctico usando estos requisitos:

Recursos computacionales limitados
Idioma inglés
Tarea de análisis de sentimiento

En este caso, selecciona DistilBERT como modelo, que se muestra en la salida con aproximadamente 66 millones de parámetros y una longitud máxima de secuencia de 256.

Esta implementación permite una selección flexible del modelo mientras equilibra el compromiso entre la complejidad del modelo y las necesidades de rendimiento.

Salida Esperada:

Selected model: distilbert
Model parameters: 66,362,880
Maximum sequence length: 256

3. Tokenización

El proceso de tokenización implica varios pasos clave:

Dividir el texto en unidades más pequeñas:
- Palabras: Dividir el texto en los límites de las palabras (ej., "hola mundo" → ["hola", "mundo"])
- Subpalabras: Dividir palabras complejas en partes significativas (ej., "jugando" → ["jug", "##ando"])
- Caracteres: En algunos casos, dividir el texto en caracteres individuales para un procesamiento más granular
Aplicar reglas de tokenización específicas del modelo:
- WordPiece (BERT): Divide las palabras en unidades de subpalabras comunes
- BPE (GPT): Utiliza codificación por pares de bytes para encontrar pares de tokens comunes
- SentencePiece: Trata el texto como una secuencia de caracteres unicode
Manejar tokens especiales que tienen funciones específicas:
- [CLS]: Token de clasificación, usado para tareas a nivel de oración
- [SEP]: Token separador, marca los límites entre oraciones
- [PAD]: Tokens de relleno, usados para mantener longitudes de entrada consistentes
- [MASK]: Usado en el modelado de lenguaje enmascarado durante el pre-entrenamiento

Ejemplo: Implementación de Tokenización

from transformers import AutoTokenizer

def demonstrate_tokenization(text):
    # Initialize tokenizer (using BERT as example)
    tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
    
    # Basic tokenization
    tokens = tokenizer.tokenize(text)
    
    # Convert tokens to ids
    input_ids = tokenizer.convert_tokens_to_ids(tokens)
    
    # Create attention mask
    attention_mask = [1] * len(input_ids)
    
    # Add special tokens and pad sequence
    encoded = tokenizer(
        text,
        padding='max_length',
        truncation=True,
        max_length=128,
        return_tensors='pt'
    )
    
    return {
        'original_text': text,
        'tokens': tokens,
        'input_ids': input_ids,
        'encoded': encoded
    }

# Example usage
text = "The quick brown fox jumps over the lazy dog!"
result = demonstrate_tokenization(text)

print("Original text:", result['original_text'])
print("\nTokens:", result['tokens'])
print("\nInput IDs:", result['input_ids'])
print("\nFull encoding:", result['encoded'])

Analicemos lo que está sucediendo en este ejemplo:

Proceso de Tokenización:
- El tokenizador primero divide el texto en tokens usando la tokenización WordPiece
- Algunas palabras se dividen en subpalabras (por ejemplo, "jumps" → ["jump", "##s"])
- Se añaden tokens especiales ([CLS] al inicio, [SEP] al final)
Componentes Clave:
- input_ids: Representaciones numéricas de los tokens
- attention_mask: Indica qué tokens son de relleno (0) vs. tokens reales (1)
- La salida codificada incluye tensores listos para la entrada del modelo

Este ejemplo muestra cómo el texto sin procesar se transforma en un formato que los modelos Transformer pueden procesar, incluyendo el manejo de tokens especiales, relleno y máscaras de atención.

Salida Esperada:

Original text: The quick brown fox jumps over the lazy dog!

Tokens: ['the', 'quick', 'brown', 'fox', 'jump', '##s', 'over', 'the', 'lazy', 'dog', '!']

Input IDs: [1996, 4248, 2829, 4419, 4083, 2015, 2058, 1996, 3910, 3899, 999]

Full encoding: {
    'input_ids': tensor([[  101,  1996,  4248,  2829,  4419,  4083,  2015,  2058,  1996,  3910,
                           3899,   999,   102,     0,     0, ...]),
    'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, ...]])
}

4. Ajuste fino (opcional): Adaptación y Optimización del Modelo

El ajuste fino implica adaptar un modelo pre-entrenado a tu caso de uso específico mediante el ajuste cuidadoso de parámetros y la configuración del entrenamiento. Este proceso requiere:

Ajustar los parámetros del modelo usando datos etiquetados específicos del dominio:
- Seleccionar cuidadosamente ejemplos de entrenamiento representativos de tu dominio
- Equilibrar las distribuciones de clases para prevenir sesgos
- Considerar la aumentación de datos para conjuntos de datos limitados
Configurar la tasa de aprendizaje, tamaño de lote y número de épocas de entrenamiento:
- Comenzar con una tasa de aprendizaje pequeña (típicamente 2e-5 a 5e-5) para prevenir el olvido catastrófico
- Elegir el tamaño de lote basado en la memoria disponible y recursos computacionales
- Determinar el número óptimo de épocas mediante el rendimiento de validación
Implementar parada temprana y puntos de control del modelo:
- Monitorear métricas de validación para prevenir el sobreajuste
- Guardar los estados del modelo con mejor rendimiento durante el entrenamiento
- Usar callbacks para detener automáticamente el entrenamiento cuando el rendimiento se estabiliza

Ejemplo: Implementación del Ajuste Fino

from transformers import AutoModelForSequenceClassification, AutoTokenizer, Trainer, TrainingArguments
import torch
from torch.utils.data import Dataset
import numpy as np
from sklearn.metrics import accuracy_score, precision_recall_fscore_support

# Custom dataset class
class CustomDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, max_length=max_length)
        self.labels = labels

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

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

# 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='weighted')
    acc = accuracy_score(labels, preds)
    return {
        'accuracy': acc,
        'f1': f1,
        'precision': precision,
        'recall': recall
    }

def fine_tune_model(train_texts, train_labels, val_texts, val_labels):
    # Initialize tokenizer and model
    tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
    model = AutoModelForSequenceClassification.from_pretrained(
        'bert-base-uncased',
        num_labels=len(set(train_labels))
    )

    # Create datasets
    train_dataset = CustomDataset(train_texts, train_labels, tokenizer)
    val_dataset = CustomDataset(val_texts, val_labels, tokenizer)

    # Define training arguments
    training_args = TrainingArguments(
        output_dir='./results',
        num_train_epochs=3,
        per_device_train_batch_size=16,
        per_device_eval_batch_size=64,
        warmup_steps=500,
        weight_decay=0.01,
        logging_dir='./logs',
        logging_steps=10,
        evaluation_strategy="epoch",
        save_strategy="epoch",
        load_best_model_at_end=True,
        metric_for_best_model="f1"
    )

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

    # Train the model
    trainer.train()
    
    return model, tokenizer

# Example usage
train_texts = [
    "This product is amazing!",
    "Terrible service, would not recommend",
    "Neutral experience overall"
]
train_labels = [1, 0, 2]  # 1: positive, 0: negative, 2: neutral
val_texts = [
    "Great purchase, very satisfied",
    "Disappointing quality"
]
val_labels = [1, 0]

model, tokenizer = fine_tune_model(train_texts, train_labels, val_texts, val_labels)

Este ejemplo demuestra un proceso integral de ajuste fino que incorpora varios componentes esenciales para un entrenamiento óptimo del modelo:

Implementación de Conjunto de Datos Personalizado:
- Crea una clase de conjunto de datos especializada que maneja eficientemente tanto datos de texto como sus etiquetas correspondientes
- Implementa la interfaz Dataset de PyTorch para una integración fluida con los ciclos de entrenamiento
- Gestiona el procesamiento por lotes y la eficiencia de memoria
Cálculo Robusto de Métricas:
- Implementa métricas de evaluación completas incluyendo precisión, exactitud, recuperación y puntuación F1
- Permite el monitoreo en tiempo real del rendimiento del modelo durante el entrenamiento
- Facilita la comparación y selección de modelos
Configuración Avanzada de Entrenamiento con Mejores Prácticas de la Industria:
- Calentamiento de la Tasa de Aprendizaje: Aumenta gradualmente la tasa de aprendizaje durante los pasos iniciales de entrenamiento para prevenir gradientes inestables y asegurar una convergencia suave
- Decaimiento de Pesos: Implementa regularización L2 para prevenir el sobreajuste y mejorar la generalización del modelo
- Evaluación Estratégica: Realiza evaluaciones periódicas del modelo en datos de validación para seguir el progreso del entrenamiento
- Sistema de Puntos de Control: Guarda estados del modelo en intervalos regulares para permitir la recuperación y selección de parámetros óptimos
- Selección Inteligente de Modelo: Utiliza la puntuación F1 como la métrica principal para seleccionar la mejor versión del modelo durante el entrenamiento

Registro de Salida Esperado:

{'train_runtime': '2:34:15',
 'train_samples_per_second': 8.123,
 'train_steps_per_second': 0.508,
 'train_loss': 0.1234,
 'epoch': 3.0,
 'eval_loss': 0.2345,
 'eval_accuracy': 0.89,
 'eval_f1': 0.88,
 'eval_precision': 0.87,
 'eval_recall': 0.86}

5. Inferencia: Realizando Predicciones en el Mundo Real

La etapa de inferencia es donde tu modelo entrenado se pone en uso práctico realizando predicciones sobre datos de texto nuevos y no vistos. Este proceso involucra varios pasos críticos:

Preprocesar nuevos datos usando el mismo pipeline que los datos de entrenamiento:
- Aplicar pasos idénticos de limpieza y normalización de texto
- Usar el mismo enfoque de tokenización y vocabulario
- Asegurar un manejo consistente de caracteres especiales y formato
Generar predicciones con puntuaciones de confianza:
- Ejecutar el texto preprocesado a través del modelo
- Obtener distribuciones de probabilidad entre las clases posibles
- Aplicar criterios de umbral para la toma de decisiones
Post-procesar resultados para interpretación y uso:
- Convertir las salidas del modelo a formato legible por humanos
- Aplicar reglas de negocio o filtrado si es necesario
- Formatear resultados para integración con sistemas posteriores

Ejemplo: Pipeline Completo de Inferencia

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import numpy as np

class TextClassificationPipeline:
    def __init__(self, model_name='bert-base-uncased', device='cuda' if torch.cuda.is_available() else 'cpu'):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
        self.device = device
        self.model.to(device)
        self.model.eval()
        
    def preprocess(self, text):
        # Clean and normalize text
        text = text.lower().strip()
        
        # Tokenize
        encoded = self.tokenizer(
            text,
            truncation=True,
            padding=True,
            max_length=512,
            return_tensors='pt'
        )
        
        return {k: v.to(self.device) for k, v in encoded.items()}
    
    def predict(self, text, threshold=0.5):
        # Preprocess input
        inputs = self.preprocess(text)
        
        # Run inference
        with torch.no_grad():
            outputs = self.model(**inputs)
            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
        
        # Get predictions
        predictions = probabilities.cpu().numpy()
        
        # Post-process results
        result = {
            'label': self.model.config.id2label[predictions.argmax()],
            'confidence': float(predictions.max()),
            'all_probabilities': {
                self.model.config.id2label[i]: float(p)
                for i, p in enumerate(predictions[0])
            }
        }
        
        # Apply threshold if specified
        result['above_threshold'] = result['confidence'] >= threshold
        
        return result

def batch_inference(texts, pipeline, batch_size=32):
    results = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        batch_results = [pipeline.predict(text) for text in batch]
        results.extend(batch_results)
    return results

# Example usage
if __name__ == "__main__":
    # Initialize pipeline
    pipeline = TextClassificationPipeline()
    
    # Example texts
    texts = [
        "This product exceeded all my expectations!",
        "The customer service was absolutely horrible.",
        "The package arrived on time, as expected."
    ]
    
    # Single prediction
    print("Single Text Inference:")
    result = pipeline.predict(texts[0])
    print(f"Text: {texts[0]}")
    print(f"Prediction: {result}\n")
    
    # Batch prediction
    print("Batch Inference:")
    results = batch_inference(texts, pipeline)
    for text, result in zip(texts, results):
        print(f"Text: {text}")
        print(f"Prediction: {result}\n")

Aquí está el desglose de sus componentes principales:

Clase TextClassificationPipeline

Se inicializa con un modelo pre-entrenado (por defecto BERT) y gestiona la configuración del dispositivo (CPU/GPU)
Incluye preprocesamiento que normaliza el texto y maneja la tokenización con una longitud máxima de 512 tokens
Implementa funcionalidad de predicción con puntuación de confianza y filtrado basado en umbrales

Métodos Principales

preprocess(): Limpia el texto y lo convierte a un formato compatible con el modelo
predict(): Maneja la predicción de texto individual con una salida completa que incluye:
- Predicción de etiqueta
- Puntuación de confianza
- Distribución de probabilidad entre todas las clases posibles
batch_inference(): Procesa múltiples textos eficientemente en lotes de 32

Formato de Salida

Devuelve predicciones estructuradas con:
- Etiqueta predicha
- Puntuación de confianza
- Distribución completa de probabilidad
- Resultado de verificación de umbral

Salida Esperada:

Single Text Inference:
Text: This product exceeded all my expectations!
Prediction: {
    'label': 'POSITIVE',
    'confidence': 0.97,
    'all_probabilities': {
        'NEGATIVE': 0.01,
        'NEUTRAL': 0.02,
        'POSITIVE': 0.97
    },
    'above_threshold': True
}

Batch Inference:
Text: This product exceeded all my expectations!
Prediction: {
    'label': 'POSITIVE',
    'confidence': 0.97,
    'all_probabilities': {...}
    'above_threshold': True
}

Text: The customer service was absolutely horrible.
Prediction: {
    'label': 'NEGATIVE',
    'confidence': 0.95,
    'all_probabilities': {...}
    'above_threshold': True
}

Text: The package arrived on time, as expected.
Prediction: {
    'label': 'NEUTRAL',
    'confidence': 0.88,
    'all_probabilities': {...}
    'above_threshold': True
}

6.3.3 Aplicaciones de la Clasificación de Texto

1. Detección de Spam

Análisis del contenido del mensaje: Examen de patrones de texto, frecuencias de palabras clave y características lingüísticas
Patrones de comportamiento del remitente: Evaluación de la frecuencia de envío, patrones temporales y reputación histórica del remitente
Metadatos técnicos: Análisis de encabezados de correo, direcciones IP, registros de autenticación e información de enrutamiento
Análisis de archivos adjuntos: Escaneo de tipos de archivo sospechosos y contenido malicioso

Los sistemas modernos de detección de spam emplean técnicas avanzadas para identificar varios tipos de comunicaciones no deseadas:

Intentos sofisticados de phishing utilizando ingeniería social
Campañas dirigidas de spear-phishing
Correos masivos de marketing que violan regulaciones
Intentos de distribución de malware
Estafas de compromiso de correo empresarial (BEC)

Estos sistemas aprenden y se adaptan continuamente a nuevas amenazas, ayudando a mantener la seguridad y organización del buzón mediante:

Detección y bloqueo de amenazas en tiempo real
Filtrado adaptativo basado en retroalimentación del usuario
Integración con redes globales de inteligencia de amenazas
Cuarentena y clasificación automatizada de mensajes sospechosos

Ejemplo: Sistema Integral de Detección de Spam

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import re
from typing import List, Dict
import numpy as np

class SpamDetectionSystem:
    def __init__(self, model_name: str = 'bert-base-uncased', threshold: float = 0.5):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
        self.threshold = threshold
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        self.model.to(self.device)
        
    def preprocess_text(self, text: str) -> str:
        """Clean and normalize text input"""
        # Convert to lowercase
        text = text.lower()
        # Remove URLs
        text = re.sub(r'http\S+|www\S+|https\S+', '', text)
        # Remove email addresses
        text = re.sub(r'\S+@\S+', '', text)
        # Remove special characters
        text = re.sub(r'[^\w\s]', '', text)
        # Remove extra whitespace
        text = ' '.join(text.split())
        return text
    
    def extract_features(self, text: str) -> Dict:
        """Extract additional spam-indicative features"""
        features = {
            'contains_urgent': bool(re.search(r'urgent|immediate|act now', text.lower())),
            'contains_money': bool(re.search(r'[$€£]\d+|\d+[$€£]|money|cash', text.lower())),
            'excessive_caps': len(re.findall(r'[A-Z]{3,}', text)) > 2,
            'text_length': len(text.split()),
        }
        return features
    
    def predict(self, text: str) -> Dict:
        """Perform spam detection on a single text"""
        # Preprocess text
        cleaned_text = self.preprocess_text(text)
        
        # Extract additional features
        features = self.extract_features(text)
        
        # Tokenize
        inputs = self.tokenizer(
            cleaned_text,
            truncation=True,
            padding=True,
            max_length=512,
            return_tensors='pt'
        ).to(self.device)
        
        # Get model prediction
        self.model.eval()
        with torch.no_grad():
            outputs = self.model(**inputs)
            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
            spam_probability = float(probabilities[0][1].cpu())
        
        # Combine model prediction with rule-based features
        final_score = spam_probability
        if features['contains_urgent'] and features['contains_money']:
            final_score += 0.1
        if features['excessive_caps']:
            final_score += 0.05
            
        return {
            'is_spam': final_score >= self.threshold,
            'spam_probability': final_score,
            'features': features,
            'original_text': text,
            'cleaned_text': cleaned_text
        }
    
    def batch_predict(self, texts: List[str], batch_size: int = 32) -> List[Dict]:
        """Process multiple texts in batches"""
        results = []
        for i in range(0, len(texts), batch_size):
            batch = texts[i:i + batch_size]
            batch_results = [self.predict(text) for text in batch]
            results.extend(batch_results)
        return results

# Example usage
if __name__ == "__main__":
    # Initialize spam detector
    spam_detector = SpamDetectionSystem()
    
    # Example messages
    messages = [
        "Hey! How are you doing?",
        "URGENT! You've won $10,000,000! Send bank details NOW!!!",
        "Meeting scheduled for tomorrow at 2 PM",
        "FREE VIAGRA! Best prices! Click here NOW!!!"
    ]
    
    # Process messages
    results = spam_detector.batch_predict(messages)
    
    # Display results
    for msg, result in zip(messages, results):
        print(f"\nMessage: {msg}")
        print(f"Spam Probability: {result['spam_probability']:.2f}")
        print(f"Is Spam: {result['is_spam']}")
        print(f"Features: {result['features']}")

Desglose del Código:

Componentes Principales:
- Modelo basado en Transformers para análisis profundo de texto
- Extracción de características basada en reglas para señales adicionales
- Pipeline integral de preprocesamiento de texto
- Capacidades de procesamiento por lotes para eficiencia
Características Clave:
- Enfoque híbrido que combina ML y detección basada en reglas
- Limpieza y normalización exhaustiva de texto
- Extracción adicional de indicadores de spam
- Umbral de spam configurable
Capacidades Avanzadas:
- Soporte de aceleración GPU para procesamiento más rápido
- Procesamiento por lotes para manejar múltiples mensajes
- Informes detallados de predicción con análisis de características
- Sistema de puntuación personalizable que combina múltiples señales

2. Análisis de Retroalimentación del Cliente

Procesar y categorizar automáticamente la retroalimentación del cliente a través de múltiples dimensiones incluyendo:

Evaluación de Calidad del Producto
- Evaluaciones de rendimiento y durabilidad
- Informes de consistencia de fabricación
- Retroalimentación de funcionalidad de características
Análisis de Precios
- Métricas de percepción de valor
- Comparaciones de precios competitivos
- Retroalimentación sobre la relación precio-características
Evaluación de Experiencia de Servicio
- Calidad de interacción del servicio al cliente
- Mediciones de tiempo de respuesta
- Efectividad en la resolución de problemas
Retroalimentación de Interfaz de Usuario
- Evaluaciones de usabilidad
- Informes de eficiencia de navegación
- Preferencias de diseño y disposición

Este análisis integral permite a las empresas:

Rastrear tendencias emergentes en tiempo real
Identificar áreas específicas que requieren atención inmediata
Priorizar mejoras basadas en el impacto al cliente
Asignar recursos más efectivamente
Desarrollar hojas de ruta de productos basadas en datos

Los sistemas avanzados mejoran este proceso a través de:

Detección Inteligente de Urgencia
- Algoritmos de análisis de sentimientos
- Mecanismos de puntuación de prioridad
- Métricas de evaluación de impacto
Sistemas de Enrutamiento Automatizado
- Asignación de problemas por departamento
- Protocolos de escalamiento
- Optimización de tiempo de respuesta

Ejemplo: Sistema de Análisis Multidimensional de Retroalimentación del Cliente

from transformers import pipeline
import pandas as pd
import numpy as np
from typing import List, Dict, Union
from collections import defaultdict

class CustomerFeedbackAnalyzer:
    def __init__(self):
        # Initialize various analysis pipelines
        self.sentiment_analyzer = pipeline("sentiment-analysis")
        self.zero_shot_classifier = pipeline("zero-shot-classification")
        self.aspect_categories = [
            "product_quality", "pricing", "customer_service",
            "user_interface", "features", "reliability"
        ]
        
    def analyze_feedback(self, text: str) -> Dict[str, Union[str, float, Dict]]:
        """Comprehensive analysis of a single feedback entry"""
        results = {}
        
        # Sentiment Analysis
        sentiment = self.sentiment_analyzer(text)[0]
        results['sentiment'] = {
            'label': sentiment['label'],
            'score': sentiment['score']
        }
        
        # Aspect-based categorization
        aspect_results = self.zero_shot_classifier(
            text,
            candidate_labels=self.aspect_categories,
            multi_label=True
        )
        
        # Filter aspects with confidence > 0.3
        results['aspects'] = {
            label: score for label, score in 
            zip(aspect_results['labels'], aspect_results['scores'])
            if score > 0.3
        }
        
        # Extract key metrics
        results['metrics'] = self._extract_metrics(text)
        
        # Priority scoring
        results['priority_score'] = self._calculate_priority(
            results['sentiment'],
            results['aspects']
        )
        
        return results
    
    def _extract_metrics(self, text: str) -> Dict[str, Union[int, float]]:
        """Extract numerical metrics from feedback"""
        metrics = {
            'word_count': len(text.split()),
            'avg_word_length': np.mean([len(word) for word in text.split()]),
            'contains_rating': bool(re.search(r'\d+/\d+|\d+\s*stars?', text.lower()))
        }
        return metrics
    
    def _calculate_priority(self, sentiment: Dict, aspects: Dict) -> float:
        """Calculate priority score based on sentiment and aspects"""
        # Base priority on sentiment
        priority = 0.5  # Default medium priority
        
        # Adjust based on sentiment
        if sentiment['label'] == 'NEGATIVE' and sentiment['score'] > 0.8:
            priority += 0.3
        
        # Adjust based on critical aspects
        critical_aspects = {'customer_service', 'reliability', 'product_quality'}
        for aspect, score in aspects.items():
            if aspect in critical_aspects and score > 0.7:
                priority += 0.1
        
        return min(1.0, priority)  # Cap at 1.0
    
    def batch_analyze(self, feedback_list: List[str]) -> List[Dict]:
        """Process multiple feedback entries"""
        return [self.analyze_feedback(text) for text in feedback_list]
    
    def generate_summary_report(self, feedback_results: List[Dict]) -> Dict:
        """Generate summary statistics from analyzed feedback"""
        summary = {
            'total_feedback': len(feedback_results),
            'sentiment_distribution': defaultdict(int),
            'aspect_frequency': defaultdict(int),
            'priority_levels': {
                'high': 0,
                'medium': 0,
                'low': 0
            }
        }
        
        for result in feedback_results:
            # Count sentiments
            summary['sentiment_distribution'][result['sentiment']['label']] += 1
            
            # Count aspects
            for aspect in result['aspects'].keys():
                summary['aspect_frequency'][aspect] += 1
            
            # Categorize priority
            priority = result['priority_score']
            if priority > 0.7:
                summary['priority_levels']['high'] += 1
            elif priority > 0.3:
                summary['priority_levels']['medium'] += 1
            else:
                summary['priority_levels']['low'] += 1
        
        return summary

# Example usage
if __name__ == "__main__":
    analyzer = CustomerFeedbackAnalyzer()
    
    # Example feedback entries
    feedback_examples = [
        "The new interface is amazing! So much easier to use than before.",
        "Product quality has declined significantly. Customer service was unhelpful.",
        "Decent product but a bit pricey for what you get.",
        "System keeps crashing. This is extremely frustrating!"
    ]
    
    # Analyze feedback
    results = analyzer.batch_analyze(feedback_examples)
    
    # Generate summary report
    summary = analyzer.generate_summary_report(results)
    
    # Print detailed analysis for first feedback
    print("\nDetailed Analysis of First Feedback:")
    print(f"Text: {feedback_examples[0]}")
    print(f"Sentiment: {results[0]['sentiment']}")
    print(f"Aspects: {results[0]['aspects']}")
    print(f"Priority Score: {results[0]['priority_score']}")
    
    # Print summary statistics
    print("\nSummary Report:")
    print(f"Total Feedback Analyzed: {summary['total_feedback']}")
    print(f"Sentiment Distribution: {dict(summary['sentiment_distribution'])}")
    print(f"Priority Levels: {summary['priority_levels']}")

Desglose del Código:

Componentes Principales:
- Múltiples canales de análisis para diferentes aspectos de la retroalimentación
- Análisis integral de retroalimentación que abarca sentimiento, aspectos y métricas
- Sistema de puntuación de prioridad para clasificación de retroalimentación
- Capacidades de procesamiento por lotes para mayor eficiencia
Características Clave:
- Análisis multidimensional que incorpora clasificación basada en sentimientos y aspectos
- Categorización flexible de aspectos utilizando clasificación de tipo zero-shot
- Extracción de métricas para análisis cuantitativo
- Puntuación de prioridad basada en múltiples factores
Capacidades Avanzadas:
- Análisis detallado de retroalimentación individual
- Procesamiento por lotes para múltiples entradas de retroalimentación
- Generación de informes resumidos con estadísticas clave
- Categorías de aspectos y puntuación de prioridad personalizables

Esta implementación proporciona una base sólida para analizar la retroalimentación del cliente, permitiendo a las empresas:

Identificar tendencias y patrones en el sentimiento del cliente
Priorizar problemas urgentes que requieren atención inmediata
Realizar seguimiento del rendimiento en diferentes aspectos de productos/servicios
Generar conclusiones accionables a partir de datos de retroalimentación del cliente

3. Categorización de Temas

Análisis Semántico
- Comprensión del significado profundo del texto más allá de las palabras clave
- Reconocimiento de relaciones entre conceptos
- Identificación de patrones temáticos entre documentos
Métodos de Clasificación
- Categorización jerárquica para temas anidados
- Clasificación multi-etiqueta para contenido que abarca múltiples categorías
- Adaptación dinámica de categorías basada en tendencias emergentes

Publicación Académica
- Clasificación de trabajos de investigación por campo y subcampo
- Etiquetado automático de artículos científicos
Medios y Publicación
- Categorización de noticias en tiempo real
- Curación de contenido para plataformas digitales
Plataformas en Línea
- Moderación de contenido generado por usuarios
- Organización automatizada de contenido

from transformers import pipeline
from sklearn.preprocessing import MultiLabelBinarizer
from typing import List, Dict, Union
import numpy as np
from collections import defaultdict

class TopicCategorizer:
    def __init__(self, threshold: float = 0.3):
        # Initialize zero-shot classification pipeline
        self.classifier = pipeline("zero-shot-classification")
        self.threshold = threshold
        
        # Define hierarchical topic structure
        self.topic_hierarchy = {
            "technology": ["software", "hardware", "ai", "cybersecurity"],
            "business": ["finance", "marketing", "management", "startups"],
            "science": ["physics", "biology", "chemistry", "astronomy"],
            "health": ["medicine", "nutrition", "fitness", "mental_health"]
        }
        
        # Flatten topics for initial classification
        self.main_topics = list(self.topic_hierarchy.keys())
        self.all_subtopics = [
            subtopic for subtopics in self.topic_hierarchy.values()
            for subtopic in subtopics
        ]
        
    def categorize_text(self, text: str) -> Dict[str, Union[List[str], float]]:
        """Perform hierarchical topic categorization on input text"""
        results = {}
        
        # First level: Main topic classification
        main_topic_results = self.classifier(
            text,
            candidate_labels=self.main_topics,
            multi_label=True
        )
        
        # Filter main topics above threshold
        relevant_main_topics = [
            label for label, score in 
            zip(main_topic_results['labels'], main_topic_results['scores'])
            if score > self.threshold
        ]
        
        # Second level: Subtopic classification for relevant main topics
        relevant_subtopics = []
        for main_topic in relevant_main_topics:
            subtopic_candidates = self.topic_hierarchy[main_topic]
            subtopic_results = self.classifier(
                text,
                candidate_labels=subtopic_candidates,
                multi_label=True
            )
            
            # Filter subtopics above threshold
            relevant_subtopics.extend([
                label for label, score in 
                zip(subtopic_results['labels'], subtopic_results['scores'])
                if score > self.threshold
            ])
        
        results['main_topics'] = relevant_main_topics
        results['subtopics'] = relevant_subtopics
        
        # Calculate confidence scores
        results['confidence_scores'] = {
            'main_topics': {
                label: score for label, score in 
                zip(main_topic_results['labels'], main_topic_results['scores'])
                if score > self.threshold
            },
            'subtopics': {
                label: score for label, score in 
                zip(subtopic_results['labels'], subtopic_results['scores'])
                if score > self.threshold
            }
        }
        
        return results
    
    def batch_categorize(self, texts: List[str]) -> List[Dict]:
        """Process multiple texts for categorization"""
        return [self.categorize_text(text) for text in texts]
    
    def generate_topic_report(self, results: List[Dict]) -> Dict:
        """Generate summary statistics from categorization results"""
        report = {
            'total_documents': len(results),
            'main_topic_distribution': defaultdict(int),
            'subtopic_distribution': defaultdict(int),
            'average_confidence': {
                'main_topics': defaultdict(list),
                'subtopics': defaultdict(list)
            }
        }
        
        for result in results:
            # Count topic occurrences
            for topic in result['main_topics']:
                report['main_topic_distribution'][topic] += 1
                
            for subtopic in result['subtopics']:
                report['subtopic_distribution'][subtopic] += 1
            
            # Collect confidence scores
            for topic, score in result['confidence_scores']['main_topics'].items():
                report['average_confidence']['main_topics'][topic].append(score)
                
            for topic, score in result['confidence_scores']['subtopics'].items():
                report['average_confidence']['subtopics'][topic].append(score)
        
        # Calculate average confidence scores
        for topic_level in ['main_topics', 'subtopics']:
            for topic, scores in report['average_confidence'][topic_level].items():
                report['average_confidence'][topic_level][topic] = \
                    np.mean(scores) if scores else 0.0
        
        return report

# Example usage
if __name__ == "__main__":
    categorizer = TopicCategorizer()
    
    # Example texts
    example_texts = [
        "New research shows quantum computers achieving unprecedented processing speeds.",
        "Start-up raises $50M for innovative AI-powered healthcare solutions.",
        "Scientists discover new exoplanet in habitable zone of nearby star."
    ]
    
    # Categorize texts
    results = categorizer.batch_categorize(example_texts)
    
    # Generate summary report
    report = categorizer.generate_topic_report(results)
    
    # Print example results
    print("\nExample Categorization Results:")
    for i, (text, result) in enumerate(zip(example_texts, results)):
        print(f"\nText {i+1}: {text}")
        print(f"Main Topics: {result['main_topics']}")
        print(f"Subtopics: {result['subtopics']}")
        print(f"Confidence Scores: {result['confidence_scores']}")
    
    # Print summary statistics
    print("\nTopic Distribution Summary:")
    print(f"Main Topics: {dict(report['main_topic_distribution'])}")
    print(f"Subtopics: {dict(report['subtopic_distribution'])}")

Desglose del Código:

Componentes Principales:
- Pipeline de clasificación zero-shot para categorización flexible de temas
- Estructura jerárquica de temas que soporta temas principales y subtemas
- Sistema de puntuación de confianza para la asignación de temas
- Capacidades de procesamiento por lotes para múltiples documentos
Características Clave:
- Enfoque de clasificación jerárquica de dos niveles
- Umbral de confianza configurable para la asignación de temas
- Puntuación detallada de confianza tanto para temas principales como subtemas
- Capacidades completas de informes y análisis
Capacidades Avanzadas:
- Clasificación multi-etiqueta que admite asignaciones de múltiples temas
- Jerarquía de temas flexible que puede modificarse fácilmente
- Métricas de rendimiento detalladas y puntuación de confianza
- Procesamiento por lotes escalable para grandes colecciones de documentos

Esta implementación proporciona una base sólida para la categorización de temas, permitiendo:

Organización automática de grandes colecciones de documentos
Sistemas de descubrimiento y recomendación de contenido
Análisis de tendencias en diferentes áreas temáticas
Evaluación de calidad de las asignaciones de temas mediante puntuaciones de confianza

4. Análisis de Sentimientos

Analizar texto para determinar el tono emocional y la actitud expresada por los clientes sobre productos, servicios o marcas. Este análisis sofisticado involucra múltiples capas de comprensión:

Análisis Emocional
- Detección básica de sentimientos (positivo/negativo/neutral)
- Reconocimiento de emociones complejas (alegría, enojo, frustración, entusiasmo)
- Medición de la intensidad de las emociones expresadas
Comprensión Contextual
- Detección de sarcasmo e ironía
- Reconocimiento de sentimientos implícitos
- Comprensión de terminología específica de la industria

Las empresas aprovechan esta profunda perspectiva emocional para múltiples propósitos estratégicos:

Monitoreo de Marca
- Seguimiento en tiempo real de la percepción de marca
- Análisis competitivo
- Detección y gestión de crisis
Desarrollo de Productos
- Priorización de características basada en sentimientos
- Optimización de la experiencia del usuario
- Oportunidades de mejora del producto
Mejora del Servicio al Cliente
- Identificación proactiva de problemas
- Medición de la calidad del servicio
- Seguimiento de la satisfacción del cliente

5. Reconocimiento de Intención

Identificar Intenciones Principales
- Reconocer objetivos principales del usuario (por ejemplo, realizar una compra, buscar información, solicitar soporte)
- Distinguir entre intenciones informativas, transaccionales y de navegación
- Mapear consultas a categorías predefinidas de intención
Manejar la Complejidad de las Consultas
- Procesar solicitudes compuestas con múltiples intenciones integradas
- Comprender intenciones implícitas a partir de pistas contextuales
- Resolver solicitudes ambiguas o poco claras del usuario

Los sistemas avanzados de reconocimiento de intención incorporan conciencia contextual y capacidades de aprendizaje para:

Mantener el Contexto de la Conversación
- Rastrear el historial de conversación para una mejor comprensión
- Considerar las preferencias del usuario e interacciones pasadas
- Adaptar respuestas basadas en el contexto situacional

from transformers import pipeline
from typing import List, Dict, Tuple, Optional
import numpy as np
from dataclasses import dataclass
from collections import defaultdict

@dataclass
class Intent:
    name: str
    confidence: float
    entities: Dict[str, str]

class IntentRecognizer:
    def __init__(self, confidence_threshold: float = 0.6):
        # Initialize zero-shot classification pipeline
        self.classifier = pipeline("zero-shot-classification")
        self.confidence_threshold = confidence_threshold
        
        # Define intent categories and their associated patterns
        self.intent_categories = {
            "purchase": ["buy", "purchase", "order", "get", "acquire"],
            "information": ["what is", "how to", "explain", "tell me about"],
            "support": ["help", "issue", "problem", "not working", "broken"],
            "comparison": ["compare", "difference between", "better than"],
            "availability": ["in stock", "available", "when can I"]
        }
        
        # Entity extraction pipeline
        self.ner_pipeline = pipeline("ner")
        
    def preprocess_text(self, text: str) -> str:
        """Clean and normalize input text"""
        return text.lower().strip()
    
    def extract_entities(self, text: str) -> Dict[str, str]:
        """Extract named entities from text"""
        entities = self.ner_pipeline(text)
        return {
            entity['entity_group']: entity['word']
            for entity in entities
        }
    
    def detect_intent(self, text: str) -> Optional[Intent]:
        """Identify primary intent from user query"""
        processed_text = self.preprocess_text(text)
        
        # Classify intent using zero-shot classification
        result = self.classifier(
            processed_text,
            candidate_labels=list(self.intent_categories.keys()),
            multi_label=False
        )
        
        # Get highest confidence intent
        primary_intent = result['labels'][0]
        confidence = result['scores'][0]
        
        if confidence >= self.confidence_threshold:
            # Extract relevant entities
            entities = self.extract_entities(text)
            
            return Intent(
                name=primary_intent,
                confidence=confidence,
                entities=entities
            )
        return None
    
    def handle_compound_intents(self, text: str) -> List[Intent]:
        """Process text for multiple potential intents"""
        sentences = text.split('.')
        intents = []
        
        for sentence in sentences:
            if sentence.strip():
                intent = self.detect_intent(sentence)
                if intent:
                    intents.append(intent)
        
        return intents
    
    def generate_response(self, intent: Intent) -> str:
        """Generate appropriate response based on detected intent"""
        responses = {
            "purchase": "I can help you make a purchase. ",
            "information": "Let me provide you with information about that. ",
            "support": "I'll help you resolve this issue. ",
            "comparison": "I can help you compare these options. ",
            "availability": "Let me check the availability for you. "
        }
        
        base_response = responses.get(intent.name, "I understand your request. ")
        
        # Add entity-specific information if available
        if intent.entities:
            entity_str = ", ".join(f"{k}: {v}" for k, v in intent.entities.items())
            base_response += f"I see you're interested in: {entity_str}"
        
        return base_response

# Example usage
if __name__ == "__main__":
    recognizer = IntentRecognizer()
    
    # Test cases
    test_queries = [
        "I want to buy a new laptop",
        "Can you explain how cloud computing works?",
        "I'm having problems with my account login",
        "What's the difference between Python and JavaScript?",
        "When will the new iPhone be available?"
    ]
    
    for query in test_queries:
        print(f"\nQuery: {query}")
        intent = recognizer.detect_intent(query)
        if intent:
            print(f"Detected Intent: {intent.name}")
            print(f"Confidence: {intent.confidence:.2f}")
            print(f"Entities: {intent.entities}")
            print(f"Response: {recognizer.generate_response(intent)}")

Desglose del Código:

Componentes Principales:
- Pipeline de clasificación sin ejemplos para reconocimiento flexible de intención
- Pipeline de Reconocimiento de Entidades Nombradas (NER) para extracción de entidades
- Categorías de intención con patrones asociados
- Sistema de generación de respuestas basado en intenciones detectadas
Características Clave:
- Umbral de confianza configurable para detección de intenciones
- Soporte para procesamiento de intenciones compuestas
- Extracción de entidades e integración en respuestas
- Sistema integral de clasificación de intenciones
Capacidades Avanzadas:
- Detección de múltiples intenciones en consultas complejas
- Generación de respuestas contextual
- Personalización de respuestas basada en entidades
- Gestión flexible de categorías de intención

Esta implementación proporciona una base robusta para sistemas de reconocimiento de intención, permitiendo:

Comprensión del lenguaje natural en IA conversacional
Generación automatizada de respuestas de servicio al cliente
Enrutamiento inteligente de consultas de usuarios a los manejadores apropiados
Generación contextual de respuestas basada en intenciones y entidades detectadas

6.3.4 Desafíos en la Clasificación de Texto

Desequilibrio de Clases

Sobreajuste a clases mayoritarias
- Los modelos se vuelven sesgados hacia la predicción de la clase mayoritaria, incluso cuando la evidencia sugiere lo contrario
- Las características aprendidas reflejan principalmente patrones en la clase dominante
- Los límites de clasificación se sesgan hacia características de la clase mayoritaria
Pobre reconocimiento de características de clases minoritarias
- La exposición limitada a ejemplos de clases minoritarias resulta en un aprendizaje débil de características
- Los modelos luchan por identificar patrones distintivos en clases subrepresentadas
- Mayores tasas de clasificación errónea para instancias de clases minoritarias
Probabilidades de predicción sesgadas
- Los puntajes de confianza se vuelven poco fiables debido al sesgo en la distribución de clases
- Los modelos tienden a asignar probabilidades más altas a las clases mayoritarias por defecto
- La toma de decisiones basada en umbrales se vuelve menos efectiva

Para abordar estos desafíos, los profesionales emplean varias soluciones probadas:

Enfoques a nivel de datos:
- Sobremuestreo de clases minoritarias usando técnicas como SMOTE (Técnica de Sobremuestreo de Minorías Sintéticas)
- Submuestreo de clases mayoritarias preservando ejemplos importantes
- Enfoques híbridos combinando tanto sobre como submuestreo
Soluciones a nivel de algoritmo:
- Implementación de funciones de pérdida ponderadas por clase para penalizar más fuertemente los errores de clases minoritarias
- Uso de métodos de conjunto diseñados específicamente para conjuntos de datos desequilibrados
- Aplicación de enfoques de aprendizaje sensibles al costo

Vocabulario Específico del Dominio

Campos técnicos con terminología única
- Terminología médica y jerga - Incluyendo términos anatómicos complejos, nombres de enfermedades, nomenclatura de medicamentos y terminología de procedimientos que raramente aparece en conjuntos de datos de lenguaje general
- Vocabulario científico - Términos especializados de física, química y otras ciencias que tienen significados técnicos precisos
- Terminología legal - Frases y términos legales específicos que tienen significados legales precisos
Desafíos Comunes de Vocabulario
- Palabras fuera del vocabulario (OOV) que no aparecen en los datos de entrenamiento inicial del modelo
- Significados específicos del contexto de palabras comunes cuando se usan en entornos técnicos
- Acrónimos y abreviaturas específicas de la industria que pueden tener múltiples interpretaciones

Para abordar estos desafíos de vocabulario, se pueden emplear varias técnicas especializadas:

Enfoques de Solución
- Adaptación de dominio mediante pre-entrenamiento continuo en corpus específicos del campo
- Estrategias de tokenización personalizadas que manejan mejor términos técnicos
- Aumento de vocabulario especializado durante el ajuste fino
- Integración de bases de conocimiento y ontologías específicas del dominio

6.3.5 Puntos Clave

La clasificación de texto es una tarea versátil de PLN con amplias aplicaciones en diferentes industrias. En servicio al cliente, ayuda a categorizar y enrutar tickets de soporte de manera eficiente. En moderación de contenido, identifica contenido inapropiado y spam. Para organizaciones de medios, permite la categorización automática de noticias y etiquetado de contenido. Las instituciones financieras la utilizan para análisis de sentimiento de informes de mercado y clasificación automatizada de documentos.
Los Transformers como BERT y RoBERTa han revolucionado la clasificación de texto a través de su arquitectura sofisticada. Su mecanismo de auto-atención les permite capturar dependencias de largo alcance en el texto, mientras que su procesamiento bidireccional asegura una comprensión integral del contexto. El pre-entrenamiento en corpus masivos de texto permite que estos modelos aprendan representaciones ricas del lenguaje, que luego pueden aplicarse efectivamente a tareas específicas de clasificación.
El ajuste fino en conjuntos de datos específicos del dominio es crucial para optimizar el rendimiento del transformer. Este proceso implica adaptar cuidadosamente el modelo pre-entrenado para comprender la terminología, convenciones y matices específicos de la industria. Por ejemplo, un clasificador de texto médico necesita reconocer terminología especializada, mientras que un clasificador de documentos legales debe comprender lenguaje legal complejo. Esta adaptabilidad hace que los transformers sean adecuados para diversas aplicaciones, desde la clasificación de artículos científicos hasta el análisis de contenido en redes sociales.
La implementación y despliegue exitosos de sistemas de clasificación de texto requieren una atención meticulosa a varios factores. La calidad del conjunto de datos debe garantizarse mediante una cuidadosa curación y limpieza de los datos de entrenamiento. Los pasos de preprocesamiento, como la normalización de texto y tokenización, deben optimizarse para el caso de uso específico. La evaluación del modelo debe incluir métricas integrales más allá de la precisión, como la precisión, recuperación y puntuación F1, particularmente para conjuntos de datos desequilibrados. El monitoreo y las actualizaciones regulares son esenciales para mantener el rendimiento a lo largo del tiempo.

6.3 Clasificación de Texto

Las aplicaciones de la clasificación de texto abarcan diversos campos y casos de uso, incluyendo:

Detección de Spam: Más allá de la simple categorización "spam" o "no spam", los sistemas modernos analizan múltiples aspectos de los correos electrónicos, incluyendo patrones de contenido, reputación del remitente y señales contextuales para proteger a los usuarios de comunicaciones no deseadas o maliciosas.
Clasificación por Temas: Los sistemas avanzados ahora pueden categorizar contenido a través de cientos de temas y subtemas, permitiendo una organización precisa del contenido en agregadores de noticias, sistemas de gestión de contenido y bases de datos de investigación. Los ejemplos se extienden más allá de deportes y política para incluir temas técnicos, disciplinas académicas y temas emergentes.
Análisis de Sentimiento: El análisis de sentimiento moderno va más allá de las clasificaciones básicas positivo/negativo/neutral para detectar matices emocionales sutiles, sarcasmo y opiniones dependientes del contexto. Esto permite a las empresas obtener percepciones más profundas sobre el feedback de los clientes y las reacciones en redes sociales.
Reconocimiento de Intención: Los sistemas contemporáneos de reconocimiento de intención pueden identificar intenciones complejas del usuario en IA conversacional, incluyendo solicitudes de múltiples pasos, intenciones implícitas y consultas dependientes del contexto. Esta capacidad es crucial para crear interacciones humano-computadora más naturales y efectivas.

6.3.1 ¿Por qué usar Transformers para la clasificación de texto?

Los Transformers han revolucionado la clasificación de texto al ofrecer varias ventajas revolucionarias:

Comprensión Contextual

Captar el significado matizado de las palabras basándose en su contexto circundante - Por ejemplo, entender que "banco" significa una institución financiera cuando se usa cerca de palabras como "dinero" o "cuenta", pero significa la orilla de un río cuando se usa cerca de palabras como "río" o "corriente"
Comprender dependencias de largo alcance entre oraciones - El modelo puede conectar conceptos relacionados incluso cuando aparecen separados por varias oraciones, de manera similar a cómo los humanos mantienen el contexto durante una conversación
Reconocer patrones lingüísticos sutiles y modismos - En lugar de tomar las frases literalmente, los Transformers pueden entender el lenguaje figurado y expresiones comunes analizando cómo estas frases se utilizan típicamente en contexto
Manejar la ambigüedad considerando el contexto completo de uso - Cuando se encuentran con palabras o frases que podrían tener múltiples significados, el modelo evalúa todo el contexto para determinar la interpretación más apropiada, similar a cómo los humanos resuelven la ambigüedad en la conversación natural

Aprendizaje por Transferencia

Reduce la necesidad de grandes conjuntos de datos de entrenamiento específicos para cada tarea
- Los enfoques tradicionales de aprendizaje automático a menudo requerían decenas de miles de ejemplos etiquetados
- El aprendizaje por transferencia puede lograr excelentes resultados con solo cientos de ejemplos
- Particularmente valioso para dominios especializados donde los datos etiquetados son escasos
Preserva la comprensión general del lenguaje mientras se adapta a dominios específicos
- Mantiene un amplio conocimiento de patrones y estructuras del lenguaje
- Se adapta exitosamente a terminología y convenciones específicas del dominio
- Equilibra efectivamente el conocimiento general y especializado
Permite una implementación rápida para nuevos casos de uso
- Reduce significativamente el tiempo de desarrollo comparado con el entrenamiento desde cero
- Permite una adaptación rápida a requisitos emergentes
- Facilita la mejora iterativa y la experimentación
Logra un rendimiento estado del arte con un entrenamiento específico mínimo
- A menudo supera a los modelos tradicionales entrenados desde cero
- Requiere menos tiempo de ajuste fino y recursos computacionales
- Demuestra una generalización superior a nuevos ejemplos

Versatilidad

Salud: Procesamiento de registros médicos y artículos de investigación, incluyendo terminología compleja, diagnósticos, protocolos de tratamiento y datos de ensayos clínicos. Estos modelos pueden identificar entidades médicas clave y relaciones mientras mantienen los estándares de privacidad del paciente.
Finanzas: Análisis de informes de mercado y documentos financieros, desde informes trimestrales de ganancias hasta evaluaciones de riesgo. Pueden procesar terminología financiera compleja, datos numéricos y requisitos de cumplimiento regulatorio mientras comprenden el contexto específico del mercado.
Servicio al Cliente: Comprensión de consultas y retroalimentación de clientes a través de múltiples canales, incluyendo correos electrónicos, registros de chat y redes sociales. Pueden detectar el sentimiento del cliente, la urgencia y la intención mientras manejan múltiples idiomas y estilos de comunicación.
Legal: Procesamiento de documentos legales y jurisprudencia, incluyendo contratos, patentes y decisiones judiciales. Estos modelos pueden comprender terminología legal compleja, precedentes y variaciones jurisdiccionales mientras mantienen la precisión en interpretaciones legales sensibles.

6.3.2 Pasos para la Clasificación de Texto con Transformers

1. Preparación de Datos

Limpieza y Estandarización

Eliminar caracteres irrelevantes, símbolos especiales y espacios en blanco innecesarios
- Eliminar etiquetas HTML y artefactos de formato
- Eliminar o reemplazar caracteres no imprimibles
- Estandarizar caracteres Unicode y codificaciones
Manejar valores faltantes e inconsistencias en el texto
- Identificar y manejar valores NULL apropiadamente
- Tratar con entradas de texto truncadas o corruptas
- Estandarizar patrones de formato inconsistentes
Normalizar texto (ej., minúsculas, eliminar acentos)
- Convertir todo el texto a un formato consistente (típicamente minúsculas)
- Eliminar o estandarizar marcas diacríticas
- Estandarizar puntuación y espaciado
Dividir datos en conjuntos de entrenamiento, validación y prueba
- Típicamente usar 70-80% para entrenamiento
- 10-15% para validación durante el desarrollo del modelo
- 10-15% para pruebas finales y evaluación
- Asegurar una distribución equilibrada de clases entre las divisiones

Ejemplo: Pipeline de Preparación de Datos

import pandas as pd
import re
from sklearn.model_selection import train_test_split

def clean_text(text):
    # Remove HTML tags
    text = re.sub(r'<[^>]+>', '', text)
    
    # Remove special characters and digits
    text = re.sub(r'[^a-zA-Z\s]', '', text)
    
    # Convert to lowercase
    text = text.lower()
    
    # Remove extra whitespace
    text = ' '.join(text.split())
    
    return text

# Load raw data
df = pd.read_csv('raw_data.csv')

# Clean text data
df['cleaned_text'] = df['text'].apply(clean_text)

# Split data while maintaining class distribution
train_data, temp_data = train_test_split(
    df, 
    test_size=0.3,
    stratify=df['label'],
    random_state=42
)

# Split temp data into validation and test sets
val_data, test_data = train_test_split(
    temp_data,
    test_size=0.5,
    stratify=temp_data['label'],
    random_state=42
)

print(f"Training samples: {len(train_data)}")
print(f"Validation samples: {len(val_data)}")
print(f"Test samples: {len(test_data)}")

Aquí está el desglose de sus componentes principales:

Importaciones y Configuración

Utiliza pandas para el manejo de datos, re para expresiones regulares y sklearn para la división de datos

Función de Limpieza de Texto

La función clean_text() realiza varios pasos de preprocesamiento:

Elimina etiquetas HTML
Elimina caracteres especiales y dígitos
Convierte el texto a minúsculas
Elimina espacios en blanco extra

Carga y Limpieza de Datos

Carga datos desde un archivo CSV
Aplica la función de limpieza a la columna de texto

División de Datos

El código implementa una división en dos etapas de los datos:

Primera división: 70% entrenamiento, 30% datos temporales
Segunda división: Los datos temporales se dividen equitativamente entre conjuntos de validación y prueba
Utiliza estratificación para mantener la distribución de clases en todas las divisiones

Resultados

La distribución final del conjunto de datos:

Conjunto de entrenamiento: 7,000 muestras
Conjunto de validación: 1,500 muestras
Conjunto de prueba: 1,500 muestras

Esta división sigue la práctica recomendada de usar 70-80% para entrenamiento y 10-15% cada uno para validación y pruebas.

Salida Esperada:

Training samples: 7000
Validation samples: 1500
Test samples: 1500

2. Selección del Modelo: Consideraciones Clave

La elección de un modelo Transformer pre-entrenado apropiado requiere una evaluación cuidadosa de varios factores críticos:

Considerar factores como el tamaño del modelo, requisitos computacionales y soporte de idiomas:
- El tamaño del modelo afecta el uso de memoria y la velocidad de inferencia
- Los requisitos de GPU/CPU impactan los costos de implementación
- El soporte de idiomas determina las capacidades multilingües
Las opciones populares incluyen:
- BERT: Excelente para tareas de clasificación de propósito general
- RoBERTa: Versión mejorada de BERT con entrenamiento optimizado
- DistilBERT: Variante más ligera y rápida, ideal para restricciones de recursos
- XLNet: Modelo avanzado mejor en el manejo de dependencias de largo alcance
Evaluar el equilibrio entre la complejidad del modelo y las necesidades de rendimiento:
- Los modelos más grandes generalmente ofrecen mejor precisión pero inferencia más lenta
- Los modelos más pequeños proporcionan procesamiento más rápido pero pueden sacrificar algo de precisión
- Considerar los requisitos y restricciones específicos de tu caso de uso

Ejemplo: Guía de Selección de Modelo

from transformers import AutoModelForSequenceClassification, AutoTokenizer

def select_model(task_requirements):
    if task_requirements['computational_resources'] == 'limited':
        # Lightweight model for resource-constrained environments
        model_name = "distilbert-base-uncased"
        max_length = 256
    elif task_requirements['language'] == 'multilingual':
        # Multilingual model for cross-language tasks
        model_name = "xlm-roberta-base"
        max_length = 512
    else:
        # Full-size model for maximum accuracy
        model_name = "roberta-large"
        max_length = 512
    
    # Load model and tokenizer
    model = AutoModelForSequenceClassification.from_pretrained(model_name)
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    
    return model, tokenizer, max_length

# Example usage
requirements = {
    'computational_resources': 'limited',
    'language': 'english',
    'task': 'sentiment_analysis'
}

model, tokenizer, max_length = select_model(requirements)
print(f"Selected model: {model.config.model_type}")
print(f"Model parameters: {model.num_parameters():,}")
print(f"Maximum sequence length: {max_length}")

Aquí está el desglose de sus componentes principales:

Definición de la Función:

La función select_model elige un modelo pre-entrenado apropiado basado en requisitos específicos de la tarea:

Para recursos computacionales limitados: Utiliza DistilBERT (un modelo ligero) con longitud de secuencia de 256
Para tareas multilingües: Utiliza XLM-RoBERTa con longitud de secuencia de 512
Para máxima precisión: Utiliza RoBERTa-large con longitud de secuencia de 512

Lógica de Selección del Modelo:

La función considera tres factores principales:

Tamaño del modelo y uso de memoria
Requisitos de GPU/CPU
Capacidades de soporte de idiomas

Ejemplo de Implementación:

El código incluye un ejemplo práctico usando estos requisitos:

Recursos computacionales limitados
Idioma inglés
Tarea de análisis de sentimiento

En este caso, selecciona DistilBERT como modelo, que se muestra en la salida con aproximadamente 66 millones de parámetros y una longitud máxima de secuencia de 256.

Esta implementación permite una selección flexible del modelo mientras equilibra el compromiso entre la complejidad del modelo y las necesidades de rendimiento.

Salida Esperada:

Selected model: distilbert
Model parameters: 66,362,880
Maximum sequence length: 256

3. Tokenización

El proceso de tokenización implica varios pasos clave:

Dividir el texto en unidades más pequeñas:
- Palabras: Dividir el texto en los límites de las palabras (ej., "hola mundo" → ["hola", "mundo"])
- Subpalabras: Dividir palabras complejas en partes significativas (ej., "jugando" → ["jug", "##ando"])
- Caracteres: En algunos casos, dividir el texto en caracteres individuales para un procesamiento más granular
Aplicar reglas de tokenización específicas del modelo:
- WordPiece (BERT): Divide las palabras en unidades de subpalabras comunes
- BPE (GPT): Utiliza codificación por pares de bytes para encontrar pares de tokens comunes
- SentencePiece: Trata el texto como una secuencia de caracteres unicode
Manejar tokens especiales que tienen funciones específicas:
- [CLS]: Token de clasificación, usado para tareas a nivel de oración
- [SEP]: Token separador, marca los límites entre oraciones
- [PAD]: Tokens de relleno, usados para mantener longitudes de entrada consistentes
- [MASK]: Usado en el modelado de lenguaje enmascarado durante el pre-entrenamiento

Ejemplo: Implementación de Tokenización

from transformers import AutoTokenizer

def demonstrate_tokenization(text):
    # Initialize tokenizer (using BERT as example)
    tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
    
    # Basic tokenization
    tokens = tokenizer.tokenize(text)
    
    # Convert tokens to ids
    input_ids = tokenizer.convert_tokens_to_ids(tokens)
    
    # Create attention mask
    attention_mask = [1] * len(input_ids)
    
    # Add special tokens and pad sequence
    encoded = tokenizer(
        text,
        padding='max_length',
        truncation=True,
        max_length=128,
        return_tensors='pt'
    )
    
    return {
        'original_text': text,
        'tokens': tokens,
        'input_ids': input_ids,
        'encoded': encoded
    }

# Example usage
text = "The quick brown fox jumps over the lazy dog!"
result = demonstrate_tokenization(text)

print("Original text:", result['original_text'])
print("\nTokens:", result['tokens'])
print("\nInput IDs:", result['input_ids'])
print("\nFull encoding:", result['encoded'])

Analicemos lo que está sucediendo en este ejemplo:

Proceso de Tokenización:
- El tokenizador primero divide el texto en tokens usando la tokenización WordPiece
- Algunas palabras se dividen en subpalabras (por ejemplo, "jumps" → ["jump", "##s"])
- Se añaden tokens especiales ([CLS] al inicio, [SEP] al final)
Componentes Clave:
- input_ids: Representaciones numéricas de los tokens
- attention_mask: Indica qué tokens son de relleno (0) vs. tokens reales (1)
- La salida codificada incluye tensores listos para la entrada del modelo

Este ejemplo muestra cómo el texto sin procesar se transforma en un formato que los modelos Transformer pueden procesar, incluyendo el manejo de tokens especiales, relleno y máscaras de atención.

Salida Esperada:

Original text: The quick brown fox jumps over the lazy dog!

Tokens: ['the', 'quick', 'brown', 'fox', 'jump', '##s', 'over', 'the', 'lazy', 'dog', '!']

Input IDs: [1996, 4248, 2829, 4419, 4083, 2015, 2058, 1996, 3910, 3899, 999]

Full encoding: {
    'input_ids': tensor([[  101,  1996,  4248,  2829,  4419,  4083,  2015,  2058,  1996,  3910,
                           3899,   999,   102,     0,     0, ...]),
    'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, ...]])
}

4. Ajuste fino (opcional): Adaptación y Optimización del Modelo

El ajuste fino implica adaptar un modelo pre-entrenado a tu caso de uso específico mediante el ajuste cuidadoso de parámetros y la configuración del entrenamiento. Este proceso requiere:

Ajustar los parámetros del modelo usando datos etiquetados específicos del dominio:
- Seleccionar cuidadosamente ejemplos de entrenamiento representativos de tu dominio
- Equilibrar las distribuciones de clases para prevenir sesgos
- Considerar la aumentación de datos para conjuntos de datos limitados
Configurar la tasa de aprendizaje, tamaño de lote y número de épocas de entrenamiento:
- Comenzar con una tasa de aprendizaje pequeña (típicamente 2e-5 a 5e-5) para prevenir el olvido catastrófico
- Elegir el tamaño de lote basado en la memoria disponible y recursos computacionales
- Determinar el número óptimo de épocas mediante el rendimiento de validación
Implementar parada temprana y puntos de control del modelo:
- Monitorear métricas de validación para prevenir el sobreajuste
- Guardar los estados del modelo con mejor rendimiento durante el entrenamiento
- Usar callbacks para detener automáticamente el entrenamiento cuando el rendimiento se estabiliza

Ejemplo: Implementación del Ajuste Fino

from transformers import AutoModelForSequenceClassification, AutoTokenizer, Trainer, TrainingArguments
import torch
from torch.utils.data import Dataset
import numpy as np
from sklearn.metrics import accuracy_score, precision_recall_fscore_support

# Custom dataset class
class CustomDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, max_length=max_length)
        self.labels = labels

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

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

# 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='weighted')
    acc = accuracy_score(labels, preds)
    return {
        'accuracy': acc,
        'f1': f1,
        'precision': precision,
        'recall': recall
    }

def fine_tune_model(train_texts, train_labels, val_texts, val_labels):
    # Initialize tokenizer and model
    tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
    model = AutoModelForSequenceClassification.from_pretrained(
        'bert-base-uncased',
        num_labels=len(set(train_labels))
    )

    # Create datasets
    train_dataset = CustomDataset(train_texts, train_labels, tokenizer)
    val_dataset = CustomDataset(val_texts, val_labels, tokenizer)

    # Define training arguments
    training_args = TrainingArguments(
        output_dir='./results',
        num_train_epochs=3,
        per_device_train_batch_size=16,
        per_device_eval_batch_size=64,
        warmup_steps=500,
        weight_decay=0.01,
        logging_dir='./logs',
        logging_steps=10,
        evaluation_strategy="epoch",
        save_strategy="epoch",
        load_best_model_at_end=True,
        metric_for_best_model="f1"
    )

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

    # Train the model
    trainer.train()
    
    return model, tokenizer

# Example usage
train_texts = [
    "This product is amazing!",
    "Terrible service, would not recommend",
    "Neutral experience overall"
]
train_labels = [1, 0, 2]  # 1: positive, 0: negative, 2: neutral
val_texts = [
    "Great purchase, very satisfied",
    "Disappointing quality"
]
val_labels = [1, 0]

model, tokenizer = fine_tune_model(train_texts, train_labels, val_texts, val_labels)

Este ejemplo demuestra un proceso integral de ajuste fino que incorpora varios componentes esenciales para un entrenamiento óptimo del modelo:

Implementación de Conjunto de Datos Personalizado:
- Crea una clase de conjunto de datos especializada que maneja eficientemente tanto datos de texto como sus etiquetas correspondientes
- Implementa la interfaz Dataset de PyTorch para una integración fluida con los ciclos de entrenamiento
- Gestiona el procesamiento por lotes y la eficiencia de memoria
Cálculo Robusto de Métricas:
- Implementa métricas de evaluación completas incluyendo precisión, exactitud, recuperación y puntuación F1
- Permite el monitoreo en tiempo real del rendimiento del modelo durante el entrenamiento
- Facilita la comparación y selección de modelos
Configuración Avanzada de Entrenamiento con Mejores Prácticas de la Industria:
- Calentamiento de la Tasa de Aprendizaje: Aumenta gradualmente la tasa de aprendizaje durante los pasos iniciales de entrenamiento para prevenir gradientes inestables y asegurar una convergencia suave
- Decaimiento de Pesos: Implementa regularización L2 para prevenir el sobreajuste y mejorar la generalización del modelo
- Evaluación Estratégica: Realiza evaluaciones periódicas del modelo en datos de validación para seguir el progreso del entrenamiento
- Sistema de Puntos de Control: Guarda estados del modelo en intervalos regulares para permitir la recuperación y selección de parámetros óptimos
- Selección Inteligente de Modelo: Utiliza la puntuación F1 como la métrica principal para seleccionar la mejor versión del modelo durante el entrenamiento

Registro de Salida Esperado:

{'train_runtime': '2:34:15',
 'train_samples_per_second': 8.123,
 'train_steps_per_second': 0.508,
 'train_loss': 0.1234,
 'epoch': 3.0,
 'eval_loss': 0.2345,
 'eval_accuracy': 0.89,
 'eval_f1': 0.88,
 'eval_precision': 0.87,
 'eval_recall': 0.86}

5. Inferencia: Realizando Predicciones en el Mundo Real

La etapa de inferencia es donde tu modelo entrenado se pone en uso práctico realizando predicciones sobre datos de texto nuevos y no vistos. Este proceso involucra varios pasos críticos:

Preprocesar nuevos datos usando el mismo pipeline que los datos de entrenamiento:
- Aplicar pasos idénticos de limpieza y normalización de texto
- Usar el mismo enfoque de tokenización y vocabulario
- Asegurar un manejo consistente de caracteres especiales y formato
Generar predicciones con puntuaciones de confianza:
- Ejecutar el texto preprocesado a través del modelo
- Obtener distribuciones de probabilidad entre las clases posibles
- Aplicar criterios de umbral para la toma de decisiones
Post-procesar resultados para interpretación y uso:
- Convertir las salidas del modelo a formato legible por humanos
- Aplicar reglas de negocio o filtrado si es necesario
- Formatear resultados para integración con sistemas posteriores

Ejemplo: Pipeline Completo de Inferencia

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import numpy as np

class TextClassificationPipeline:
    def __init__(self, model_name='bert-base-uncased', device='cuda' if torch.cuda.is_available() else 'cpu'):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
        self.device = device
        self.model.to(device)
        self.model.eval()
        
    def preprocess(self, text):
        # Clean and normalize text
        text = text.lower().strip()
        
        # Tokenize
        encoded = self.tokenizer(
            text,
            truncation=True,
            padding=True,
            max_length=512,
            return_tensors='pt'
        )
        
        return {k: v.to(self.device) for k, v in encoded.items()}
    
    def predict(self, text, threshold=0.5):
        # Preprocess input
        inputs = self.preprocess(text)
        
        # Run inference
        with torch.no_grad():
            outputs = self.model(**inputs)
            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
        
        # Get predictions
        predictions = probabilities.cpu().numpy()
        
        # Post-process results
        result = {
            'label': self.model.config.id2label[predictions.argmax()],
            'confidence': float(predictions.max()),
            'all_probabilities': {
                self.model.config.id2label[i]: float(p)
                for i, p in enumerate(predictions[0])
            }
        }
        
        # Apply threshold if specified
        result['above_threshold'] = result['confidence'] >= threshold
        
        return result

def batch_inference(texts, pipeline, batch_size=32):
    results = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        batch_results = [pipeline.predict(text) for text in batch]
        results.extend(batch_results)
    return results

# Example usage
if __name__ == "__main__":
    # Initialize pipeline
    pipeline = TextClassificationPipeline()
    
    # Example texts
    texts = [
        "This product exceeded all my expectations!",
        "The customer service was absolutely horrible.",
        "The package arrived on time, as expected."
    ]
    
    # Single prediction
    print("Single Text Inference:")
    result = pipeline.predict(texts[0])
    print(f"Text: {texts[0]}")
    print(f"Prediction: {result}\n")
    
    # Batch prediction
    print("Batch Inference:")
    results = batch_inference(texts, pipeline)
    for text, result in zip(texts, results):
        print(f"Text: {text}")
        print(f"Prediction: {result}\n")

Aquí está el desglose de sus componentes principales:

Clase TextClassificationPipeline

Se inicializa con un modelo pre-entrenado (por defecto BERT) y gestiona la configuración del dispositivo (CPU/GPU)
Incluye preprocesamiento que normaliza el texto y maneja la tokenización con una longitud máxima de 512 tokens
Implementa funcionalidad de predicción con puntuación de confianza y filtrado basado en umbrales

Métodos Principales

preprocess(): Limpia el texto y lo convierte a un formato compatible con el modelo
predict(): Maneja la predicción de texto individual con una salida completa que incluye:
- Predicción de etiqueta
- Puntuación de confianza
- Distribución de probabilidad entre todas las clases posibles
batch_inference(): Procesa múltiples textos eficientemente en lotes de 32

Formato de Salida

Devuelve predicciones estructuradas con:
- Etiqueta predicha
- Puntuación de confianza
- Distribución completa de probabilidad
- Resultado de verificación de umbral

Salida Esperada:

Single Text Inference:
Text: This product exceeded all my expectations!
Prediction: {
    'label': 'POSITIVE',
    'confidence': 0.97,
    'all_probabilities': {
        'NEGATIVE': 0.01,
        'NEUTRAL': 0.02,
        'POSITIVE': 0.97
    },
    'above_threshold': True
}

Batch Inference:
Text: This product exceeded all my expectations!
Prediction: {
    'label': 'POSITIVE',
    'confidence': 0.97,
    'all_probabilities': {...}
    'above_threshold': True
}

Text: The customer service was absolutely horrible.
Prediction: {
    'label': 'NEGATIVE',
    'confidence': 0.95,
    'all_probabilities': {...}
    'above_threshold': True
}

Text: The package arrived on time, as expected.
Prediction: {
    'label': 'NEUTRAL',
    'confidence': 0.88,
    'all_probabilities': {...}
    'above_threshold': True
}

6.3.3 Aplicaciones de la Clasificación de Texto

1. Detección de Spam

Análisis del contenido del mensaje: Examen de patrones de texto, frecuencias de palabras clave y características lingüísticas
Patrones de comportamiento del remitente: Evaluación de la frecuencia de envío, patrones temporales y reputación histórica del remitente
Metadatos técnicos: Análisis de encabezados de correo, direcciones IP, registros de autenticación e información de enrutamiento
Análisis de archivos adjuntos: Escaneo de tipos de archivo sospechosos y contenido malicioso

Los sistemas modernos de detección de spam emplean técnicas avanzadas para identificar varios tipos de comunicaciones no deseadas:

Intentos sofisticados de phishing utilizando ingeniería social
Campañas dirigidas de spear-phishing
Correos masivos de marketing que violan regulaciones
Intentos de distribución de malware
Estafas de compromiso de correo empresarial (BEC)

Estos sistemas aprenden y se adaptan continuamente a nuevas amenazas, ayudando a mantener la seguridad y organización del buzón mediante:

Detección y bloqueo de amenazas en tiempo real
Filtrado adaptativo basado en retroalimentación del usuario
Integración con redes globales de inteligencia de amenazas
Cuarentena y clasificación automatizada de mensajes sospechosos

Ejemplo: Sistema Integral de Detección de Spam

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import re
from typing import List, Dict
import numpy as np

class SpamDetectionSystem:
    def __init__(self, model_name: str = 'bert-base-uncased', threshold: float = 0.5):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
        self.threshold = threshold
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        self.model.to(self.device)
        
    def preprocess_text(self, text: str) -> str:
        """Clean and normalize text input"""
        # Convert to lowercase
        text = text.lower()
        # Remove URLs
        text = re.sub(r'http\S+|www\S+|https\S+', '', text)
        # Remove email addresses
        text = re.sub(r'\S+@\S+', '', text)
        # Remove special characters
        text = re.sub(r'[^\w\s]', '', text)
        # Remove extra whitespace
        text = ' '.join(text.split())
        return text
    
    def extract_features(self, text: str) -> Dict:
        """Extract additional spam-indicative features"""
        features = {
            'contains_urgent': bool(re.search(r'urgent|immediate|act now', text.lower())),
            'contains_money': bool(re.search(r'[$€£]\d+|\d+[$€£]|money|cash', text.lower())),
            'excessive_caps': len(re.findall(r'[A-Z]{3,}', text)) > 2,
            'text_length': len(text.split()),
        }
        return features
    
    def predict(self, text: str) -> Dict:
        """Perform spam detection on a single text"""
        # Preprocess text
        cleaned_text = self.preprocess_text(text)
        
        # Extract additional features
        features = self.extract_features(text)
        
        # Tokenize
        inputs = self.tokenizer(
            cleaned_text,
            truncation=True,
            padding=True,
            max_length=512,
            return_tensors='pt'
        ).to(self.device)
        
        # Get model prediction
        self.model.eval()
        with torch.no_grad():
            outputs = self.model(**inputs)
            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
            spam_probability = float(probabilities[0][1].cpu())
        
        # Combine model prediction with rule-based features
        final_score = spam_probability
        if features['contains_urgent'] and features['contains_money']:
            final_score += 0.1
        if features['excessive_caps']:
            final_score += 0.05
            
        return {
            'is_spam': final_score >= self.threshold,
            'spam_probability': final_score,
            'features': features,
            'original_text': text,
            'cleaned_text': cleaned_text
        }
    
    def batch_predict(self, texts: List[str], batch_size: int = 32) -> List[Dict]:
        """Process multiple texts in batches"""
        results = []
        for i in range(0, len(texts), batch_size):
            batch = texts[i:i + batch_size]
            batch_results = [self.predict(text) for text in batch]
            results.extend(batch_results)
        return results

# Example usage
if __name__ == "__main__":
    # Initialize spam detector
    spam_detector = SpamDetectionSystem()
    
    # Example messages
    messages = [
        "Hey! How are you doing?",
        "URGENT! You've won $10,000,000! Send bank details NOW!!!",
        "Meeting scheduled for tomorrow at 2 PM",
        "FREE VIAGRA! Best prices! Click here NOW!!!"
    ]
    
    # Process messages
    results = spam_detector.batch_predict(messages)
    
    # Display results
    for msg, result in zip(messages, results):
        print(f"\nMessage: {msg}")
        print(f"Spam Probability: {result['spam_probability']:.2f}")
        print(f"Is Spam: {result['is_spam']}")
        print(f"Features: {result['features']}")

Desglose del Código:

Componentes Principales:
- Modelo basado en Transformers para análisis profundo de texto
- Extracción de características basada en reglas para señales adicionales
- Pipeline integral de preprocesamiento de texto
- Capacidades de procesamiento por lotes para eficiencia
Características Clave:
- Enfoque híbrido que combina ML y detección basada en reglas
- Limpieza y normalización exhaustiva de texto
- Extracción adicional de indicadores de spam
- Umbral de spam configurable
Capacidades Avanzadas:
- Soporte de aceleración GPU para procesamiento más rápido
- Procesamiento por lotes para manejar múltiples mensajes
- Informes detallados de predicción con análisis de características
- Sistema de puntuación personalizable que combina múltiples señales

2. Análisis de Retroalimentación del Cliente

Procesar y categorizar automáticamente la retroalimentación del cliente a través de múltiples dimensiones incluyendo:

Evaluación de Calidad del Producto
- Evaluaciones de rendimiento y durabilidad
- Informes de consistencia de fabricación
- Retroalimentación de funcionalidad de características
Análisis de Precios
- Métricas de percepción de valor
- Comparaciones de precios competitivos
- Retroalimentación sobre la relación precio-características
Evaluación de Experiencia de Servicio
- Calidad de interacción del servicio al cliente
- Mediciones de tiempo de respuesta
- Efectividad en la resolución de problemas
Retroalimentación de Interfaz de Usuario
- Evaluaciones de usabilidad
- Informes de eficiencia de navegación
- Preferencias de diseño y disposición

Este análisis integral permite a las empresas:

Rastrear tendencias emergentes en tiempo real
Identificar áreas específicas que requieren atención inmediata
Priorizar mejoras basadas en el impacto al cliente
Asignar recursos más efectivamente
Desarrollar hojas de ruta de productos basadas en datos

Los sistemas avanzados mejoran este proceso a través de:

Detección Inteligente de Urgencia
- Algoritmos de análisis de sentimientos
- Mecanismos de puntuación de prioridad
- Métricas de evaluación de impacto
Sistemas de Enrutamiento Automatizado
- Asignación de problemas por departamento
- Protocolos de escalamiento
- Optimización de tiempo de respuesta

Ejemplo: Sistema de Análisis Multidimensional de Retroalimentación del Cliente

from transformers import pipeline
import pandas as pd
import numpy as np
from typing import List, Dict, Union
from collections import defaultdict

class CustomerFeedbackAnalyzer:
    def __init__(self):
        # Initialize various analysis pipelines
        self.sentiment_analyzer = pipeline("sentiment-analysis")
        self.zero_shot_classifier = pipeline("zero-shot-classification")
        self.aspect_categories = [
            "product_quality", "pricing", "customer_service",
            "user_interface", "features", "reliability"
        ]
        
    def analyze_feedback(self, text: str) -> Dict[str, Union[str, float, Dict]]:
        """Comprehensive analysis of a single feedback entry"""
        results = {}
        
        # Sentiment Analysis
        sentiment = self.sentiment_analyzer(text)[0]
        results['sentiment'] = {
            'label': sentiment['label'],
            'score': sentiment['score']
        }
        
        # Aspect-based categorization
        aspect_results = self.zero_shot_classifier(
            text,
            candidate_labels=self.aspect_categories,
            multi_label=True
        )
        
        # Filter aspects with confidence > 0.3
        results['aspects'] = {
            label: score for label, score in 
            zip(aspect_results['labels'], aspect_results['scores'])
            if score > 0.3
        }
        
        # Extract key metrics
        results['metrics'] = self._extract_metrics(text)
        
        # Priority scoring
        results['priority_score'] = self._calculate_priority(
            results['sentiment'],
            results['aspects']
        )
        
        return results
    
    def _extract_metrics(self, text: str) -> Dict[str, Union[int, float]]:
        """Extract numerical metrics from feedback"""
        metrics = {
            'word_count': len(text.split()),
            'avg_word_length': np.mean([len(word) for word in text.split()]),
            'contains_rating': bool(re.search(r'\d+/\d+|\d+\s*stars?', text.lower()))
        }
        return metrics
    
    def _calculate_priority(self, sentiment: Dict, aspects: Dict) -> float:
        """Calculate priority score based on sentiment and aspects"""
        # Base priority on sentiment
        priority = 0.5  # Default medium priority
        
        # Adjust based on sentiment
        if sentiment['label'] == 'NEGATIVE' and sentiment['score'] > 0.8:
            priority += 0.3
        
        # Adjust based on critical aspects
        critical_aspects = {'customer_service', 'reliability', 'product_quality'}
        for aspect, score in aspects.items():
            if aspect in critical_aspects and score > 0.7:
                priority += 0.1
        
        return min(1.0, priority)  # Cap at 1.0
    
    def batch_analyze(self, feedback_list: List[str]) -> List[Dict]:
        """Process multiple feedback entries"""
        return [self.analyze_feedback(text) for text in feedback_list]
    
    def generate_summary_report(self, feedback_results: List[Dict]) -> Dict:
        """Generate summary statistics from analyzed feedback"""
        summary = {
            'total_feedback': len(feedback_results),
            'sentiment_distribution': defaultdict(int),
            'aspect_frequency': defaultdict(int),
            'priority_levels': {
                'high': 0,
                'medium': 0,
                'low': 0
            }
        }
        
        for result in feedback_results:
            # Count sentiments
            summary['sentiment_distribution'][result['sentiment']['label']] += 1
            
            # Count aspects
            for aspect in result['aspects'].keys():
                summary['aspect_frequency'][aspect] += 1
            
            # Categorize priority
            priority = result['priority_score']
            if priority > 0.7:
                summary['priority_levels']['high'] += 1
            elif priority > 0.3:
                summary['priority_levels']['medium'] += 1
            else:
                summary['priority_levels']['low'] += 1
        
        return summary

# Example usage
if __name__ == "__main__":
    analyzer = CustomerFeedbackAnalyzer()
    
    # Example feedback entries
    feedback_examples = [
        "The new interface is amazing! So much easier to use than before.",
        "Product quality has declined significantly. Customer service was unhelpful.",
        "Decent product but a bit pricey for what you get.",
        "System keeps crashing. This is extremely frustrating!"
    ]
    
    # Analyze feedback
    results = analyzer.batch_analyze(feedback_examples)
    
    # Generate summary report
    summary = analyzer.generate_summary_report(results)
    
    # Print detailed analysis for first feedback
    print("\nDetailed Analysis of First Feedback:")
    print(f"Text: {feedback_examples[0]}")
    print(f"Sentiment: {results[0]['sentiment']}")
    print(f"Aspects: {results[0]['aspects']}")
    print(f"Priority Score: {results[0]['priority_score']}")
    
    # Print summary statistics
    print("\nSummary Report:")
    print(f"Total Feedback Analyzed: {summary['total_feedback']}")
    print(f"Sentiment Distribution: {dict(summary['sentiment_distribution'])}")
    print(f"Priority Levels: {summary['priority_levels']}")

Desglose del Código:

Componentes Principales:
- Múltiples canales de análisis para diferentes aspectos de la retroalimentación
- Análisis integral de retroalimentación que abarca sentimiento, aspectos y métricas
- Sistema de puntuación de prioridad para clasificación de retroalimentación
- Capacidades de procesamiento por lotes para mayor eficiencia
Características Clave:
- Análisis multidimensional que incorpora clasificación basada en sentimientos y aspectos
- Categorización flexible de aspectos utilizando clasificación de tipo zero-shot
- Extracción de métricas para análisis cuantitativo
- Puntuación de prioridad basada en múltiples factores
Capacidades Avanzadas:
- Análisis detallado de retroalimentación individual
- Procesamiento por lotes para múltiples entradas de retroalimentación
- Generación de informes resumidos con estadísticas clave
- Categorías de aspectos y puntuación de prioridad personalizables

Esta implementación proporciona una base sólida para analizar la retroalimentación del cliente, permitiendo a las empresas:

Identificar tendencias y patrones en el sentimiento del cliente
Priorizar problemas urgentes que requieren atención inmediata
Realizar seguimiento del rendimiento en diferentes aspectos de productos/servicios
Generar conclusiones accionables a partir de datos de retroalimentación del cliente

3. Categorización de Temas

Análisis Semántico
- Comprensión del significado profundo del texto más allá de las palabras clave
- Reconocimiento de relaciones entre conceptos
- Identificación de patrones temáticos entre documentos
Métodos de Clasificación
- Categorización jerárquica para temas anidados
- Clasificación multi-etiqueta para contenido que abarca múltiples categorías
- Adaptación dinámica de categorías basada en tendencias emergentes

Publicación Académica
- Clasificación de trabajos de investigación por campo y subcampo
- Etiquetado automático de artículos científicos
Medios y Publicación
- Categorización de noticias en tiempo real
- Curación de contenido para plataformas digitales
Plataformas en Línea
- Moderación de contenido generado por usuarios
- Organización automatizada de contenido

from transformers import pipeline
from sklearn.preprocessing import MultiLabelBinarizer
from typing import List, Dict, Union
import numpy as np
from collections import defaultdict

class TopicCategorizer:
    def __init__(self, threshold: float = 0.3):
        # Initialize zero-shot classification pipeline
        self.classifier = pipeline("zero-shot-classification")
        self.threshold = threshold
        
        # Define hierarchical topic structure
        self.topic_hierarchy = {
            "technology": ["software", "hardware", "ai", "cybersecurity"],
            "business": ["finance", "marketing", "management", "startups"],
            "science": ["physics", "biology", "chemistry", "astronomy"],
            "health": ["medicine", "nutrition", "fitness", "mental_health"]
        }
        
        # Flatten topics for initial classification
        self.main_topics = list(self.topic_hierarchy.keys())
        self.all_subtopics = [
            subtopic for subtopics in self.topic_hierarchy.values()
            for subtopic in subtopics
        ]
        
    def categorize_text(self, text: str) -> Dict[str, Union[List[str], float]]:
        """Perform hierarchical topic categorization on input text"""
        results = {}
        
        # First level: Main topic classification
        main_topic_results = self.classifier(
            text,
            candidate_labels=self.main_topics,
            multi_label=True
        )
        
        # Filter main topics above threshold
        relevant_main_topics = [
            label for label, score in 
            zip(main_topic_results['labels'], main_topic_results['scores'])
            if score > self.threshold
        ]
        
        # Second level: Subtopic classification for relevant main topics
        relevant_subtopics = []
        for main_topic in relevant_main_topics:
            subtopic_candidates = self.topic_hierarchy[main_topic]
            subtopic_results = self.classifier(
                text,
                candidate_labels=subtopic_candidates,
                multi_label=True
            )
            
            # Filter subtopics above threshold
            relevant_subtopics.extend([
                label for label, score in 
                zip(subtopic_results['labels'], subtopic_results['scores'])
                if score > self.threshold
            ])
        
        results['main_topics'] = relevant_main_topics
        results['subtopics'] = relevant_subtopics
        
        # Calculate confidence scores
        results['confidence_scores'] = {
            'main_topics': {
                label: score for label, score in 
                zip(main_topic_results['labels'], main_topic_results['scores'])
                if score > self.threshold
            },
            'subtopics': {
                label: score for label, score in 
                zip(subtopic_results['labels'], subtopic_results['scores'])
                if score > self.threshold
            }
        }
        
        return results
    
    def batch_categorize(self, texts: List[str]) -> List[Dict]:
        """Process multiple texts for categorization"""
        return [self.categorize_text(text) for text in texts]
    
    def generate_topic_report(self, results: List[Dict]) -> Dict:
        """Generate summary statistics from categorization results"""
        report = {
            'total_documents': len(results),
            'main_topic_distribution': defaultdict(int),
            'subtopic_distribution': defaultdict(int),
            'average_confidence': {
                'main_topics': defaultdict(list),
                'subtopics': defaultdict(list)
            }
        }
        
        for result in results:
            # Count topic occurrences
            for topic in result['main_topics']:
                report['main_topic_distribution'][topic] += 1
                
            for subtopic in result['subtopics']:
                report['subtopic_distribution'][subtopic] += 1
            
            # Collect confidence scores
            for topic, score in result['confidence_scores']['main_topics'].items():
                report['average_confidence']['main_topics'][topic].append(score)
                
            for topic, score in result['confidence_scores']['subtopics'].items():
                report['average_confidence']['subtopics'][topic].append(score)
        
        # Calculate average confidence scores
        for topic_level in ['main_topics', 'subtopics']:
            for topic, scores in report['average_confidence'][topic_level].items():
                report['average_confidence'][topic_level][topic] = \
                    np.mean(scores) if scores else 0.0
        
        return report

# Example usage
if __name__ == "__main__":
    categorizer = TopicCategorizer()
    
    # Example texts
    example_texts = [
        "New research shows quantum computers achieving unprecedented processing speeds.",
        "Start-up raises $50M for innovative AI-powered healthcare solutions.",
        "Scientists discover new exoplanet in habitable zone of nearby star."
    ]
    
    # Categorize texts
    results = categorizer.batch_categorize(example_texts)
    
    # Generate summary report
    report = categorizer.generate_topic_report(results)
    
    # Print example results
    print("\nExample Categorization Results:")
    for i, (text, result) in enumerate(zip(example_texts, results)):
        print(f"\nText {i+1}: {text}")
        print(f"Main Topics: {result['main_topics']}")
        print(f"Subtopics: {result['subtopics']}")
        print(f"Confidence Scores: {result['confidence_scores']}")
    
    # Print summary statistics
    print("\nTopic Distribution Summary:")
    print(f"Main Topics: {dict(report['main_topic_distribution'])}")
    print(f"Subtopics: {dict(report['subtopic_distribution'])}")

Desglose del Código:

Componentes Principales:
- Pipeline de clasificación zero-shot para categorización flexible de temas
- Estructura jerárquica de temas que soporta temas principales y subtemas
- Sistema de puntuación de confianza para la asignación de temas
- Capacidades de procesamiento por lotes para múltiples documentos
Características Clave:
- Enfoque de clasificación jerárquica de dos niveles
- Umbral de confianza configurable para la asignación de temas
- Puntuación detallada de confianza tanto para temas principales como subtemas
- Capacidades completas de informes y análisis
Capacidades Avanzadas:
- Clasificación multi-etiqueta que admite asignaciones de múltiples temas
- Jerarquía de temas flexible que puede modificarse fácilmente
- Métricas de rendimiento detalladas y puntuación de confianza
- Procesamiento por lotes escalable para grandes colecciones de documentos

Esta implementación proporciona una base sólida para la categorización de temas, permitiendo:

Organización automática de grandes colecciones de documentos
Sistemas de descubrimiento y recomendación de contenido
Análisis de tendencias en diferentes áreas temáticas
Evaluación de calidad de las asignaciones de temas mediante puntuaciones de confianza

4. Análisis de Sentimientos

Analizar texto para determinar el tono emocional y la actitud expresada por los clientes sobre productos, servicios o marcas. Este análisis sofisticado involucra múltiples capas de comprensión:

Análisis Emocional
- Detección básica de sentimientos (positivo/negativo/neutral)
- Reconocimiento de emociones complejas (alegría, enojo, frustración, entusiasmo)
- Medición de la intensidad de las emociones expresadas
Comprensión Contextual
- Detección de sarcasmo e ironía
- Reconocimiento de sentimientos implícitos
- Comprensión de terminología específica de la industria

Las empresas aprovechan esta profunda perspectiva emocional para múltiples propósitos estratégicos:

Monitoreo de Marca
- Seguimiento en tiempo real de la percepción de marca
- Análisis competitivo
- Detección y gestión de crisis
Desarrollo de Productos
- Priorización de características basada en sentimientos
- Optimización de la experiencia del usuario
- Oportunidades de mejora del producto
Mejora del Servicio al Cliente
- Identificación proactiva de problemas
- Medición de la calidad del servicio
- Seguimiento de la satisfacción del cliente

5. Reconocimiento de Intención

Identificar Intenciones Principales
- Reconocer objetivos principales del usuario (por ejemplo, realizar una compra, buscar información, solicitar soporte)
- Distinguir entre intenciones informativas, transaccionales y de navegación
- Mapear consultas a categorías predefinidas de intención
Manejar la Complejidad de las Consultas
- Procesar solicitudes compuestas con múltiples intenciones integradas
- Comprender intenciones implícitas a partir de pistas contextuales
- Resolver solicitudes ambiguas o poco claras del usuario

Los sistemas avanzados de reconocimiento de intención incorporan conciencia contextual y capacidades de aprendizaje para:

Mantener el Contexto de la Conversación
- Rastrear el historial de conversación para una mejor comprensión
- Considerar las preferencias del usuario e interacciones pasadas
- Adaptar respuestas basadas en el contexto situacional

from transformers import pipeline
from typing import List, Dict, Tuple, Optional
import numpy as np
from dataclasses import dataclass
from collections import defaultdict

@dataclass
class Intent:
    name: str
    confidence: float
    entities: Dict[str, str]

class IntentRecognizer:
    def __init__(self, confidence_threshold: float = 0.6):
        # Initialize zero-shot classification pipeline
        self.classifier = pipeline("zero-shot-classification")
        self.confidence_threshold = confidence_threshold
        
        # Define intent categories and their associated patterns
        self.intent_categories = {
            "purchase": ["buy", "purchase", "order", "get", "acquire"],
            "information": ["what is", "how to", "explain", "tell me about"],
            "support": ["help", "issue", "problem", "not working", "broken"],
            "comparison": ["compare", "difference between", "better than"],
            "availability": ["in stock", "available", "when can I"]
        }
        
        # Entity extraction pipeline
        self.ner_pipeline = pipeline("ner")
        
    def preprocess_text(self, text: str) -> str:
        """Clean and normalize input text"""
        return text.lower().strip()
    
    def extract_entities(self, text: str) -> Dict[str, str]:
        """Extract named entities from text"""
        entities = self.ner_pipeline(text)
        return {
            entity['entity_group']: entity['word']
            for entity in entities
        }
    
    def detect_intent(self, text: str) -> Optional[Intent]:
        """Identify primary intent from user query"""
        processed_text = self.preprocess_text(text)
        
        # Classify intent using zero-shot classification
        result = self.classifier(
            processed_text,
            candidate_labels=list(self.intent_categories.keys()),
            multi_label=False
        )
        
        # Get highest confidence intent
        primary_intent = result['labels'][0]
        confidence = result['scores'][0]
        
        if confidence >= self.confidence_threshold:
            # Extract relevant entities
            entities = self.extract_entities(text)
            
            return Intent(
                name=primary_intent,
                confidence=confidence,
                entities=entities
            )
        return None
    
    def handle_compound_intents(self, text: str) -> List[Intent]:
        """Process text for multiple potential intents"""
        sentences = text.split('.')
        intents = []
        
        for sentence in sentences:
            if sentence.strip():
                intent = self.detect_intent(sentence)
                if intent:
                    intents.append(intent)
        
        return intents
    
    def generate_response(self, intent: Intent) -> str:
        """Generate appropriate response based on detected intent"""
        responses = {
            "purchase": "I can help you make a purchase. ",
            "information": "Let me provide you with information about that. ",
            "support": "I'll help you resolve this issue. ",
            "comparison": "I can help you compare these options. ",
            "availability": "Let me check the availability for you. "
        }
        
        base_response = responses.get(intent.name, "I understand your request. ")
        
        # Add entity-specific information if available
        if intent.entities:
            entity_str = ", ".join(f"{k}: {v}" for k, v in intent.entities.items())
            base_response += f"I see you're interested in: {entity_str}"
        
        return base_response

# Example usage
if __name__ == "__main__":
    recognizer = IntentRecognizer()
    
    # Test cases
    test_queries = [
        "I want to buy a new laptop",
        "Can you explain how cloud computing works?",
        "I'm having problems with my account login",
        "What's the difference between Python and JavaScript?",
        "When will the new iPhone be available?"
    ]
    
    for query in test_queries:
        print(f"\nQuery: {query}")
        intent = recognizer.detect_intent(query)
        if intent:
            print(f"Detected Intent: {intent.name}")
            print(f"Confidence: {intent.confidence:.2f}")
            print(f"Entities: {intent.entities}")
            print(f"Response: {recognizer.generate_response(intent)}")

Desglose del Código:

Componentes Principales:
- Pipeline de clasificación sin ejemplos para reconocimiento flexible de intención
- Pipeline de Reconocimiento de Entidades Nombradas (NER) para extracción de entidades
- Categorías de intención con patrones asociados
- Sistema de generación de respuestas basado en intenciones detectadas
Características Clave:
- Umbral de confianza configurable para detección de intenciones
- Soporte para procesamiento de intenciones compuestas
- Extracción de entidades e integración en respuestas
- Sistema integral de clasificación de intenciones
Capacidades Avanzadas:
- Detección de múltiples intenciones en consultas complejas
- Generación de respuestas contextual
- Personalización de respuestas basada en entidades
- Gestión flexible de categorías de intención

Esta implementación proporciona una base robusta para sistemas de reconocimiento de intención, permitiendo:

Comprensión del lenguaje natural en IA conversacional
Generación automatizada de respuestas de servicio al cliente
Enrutamiento inteligente de consultas de usuarios a los manejadores apropiados
Generación contextual de respuestas basada en intenciones y entidades detectadas

6.3.4 Desafíos en la Clasificación de Texto

Desequilibrio de Clases

Sobreajuste a clases mayoritarias
- Los modelos se vuelven sesgados hacia la predicción de la clase mayoritaria, incluso cuando la evidencia sugiere lo contrario
- Las características aprendidas reflejan principalmente patrones en la clase dominante
- Los límites de clasificación se sesgan hacia características de la clase mayoritaria
Pobre reconocimiento de características de clases minoritarias
- La exposición limitada a ejemplos de clases minoritarias resulta en un aprendizaje débil de características
- Los modelos luchan por identificar patrones distintivos en clases subrepresentadas
- Mayores tasas de clasificación errónea para instancias de clases minoritarias
Probabilidades de predicción sesgadas
- Los puntajes de confianza se vuelven poco fiables debido al sesgo en la distribución de clases
- Los modelos tienden a asignar probabilidades más altas a las clases mayoritarias por defecto
- La toma de decisiones basada en umbrales se vuelve menos efectiva

Para abordar estos desafíos, los profesionales emplean varias soluciones probadas:

Enfoques a nivel de datos:
- Sobremuestreo de clases minoritarias usando técnicas como SMOTE (Técnica de Sobremuestreo de Minorías Sintéticas)
- Submuestreo de clases mayoritarias preservando ejemplos importantes
- Enfoques híbridos combinando tanto sobre como submuestreo
Soluciones a nivel de algoritmo:
- Implementación de funciones de pérdida ponderadas por clase para penalizar más fuertemente los errores de clases minoritarias
- Uso de métodos de conjunto diseñados específicamente para conjuntos de datos desequilibrados
- Aplicación de enfoques de aprendizaje sensibles al costo

Vocabulario Específico del Dominio

Campos técnicos con terminología única
- Terminología médica y jerga - Incluyendo términos anatómicos complejos, nombres de enfermedades, nomenclatura de medicamentos y terminología de procedimientos que raramente aparece en conjuntos de datos de lenguaje general
- Vocabulario científico - Términos especializados de física, química y otras ciencias que tienen significados técnicos precisos
- Terminología legal - Frases y términos legales específicos que tienen significados legales precisos
Desafíos Comunes de Vocabulario
- Palabras fuera del vocabulario (OOV) que no aparecen en los datos de entrenamiento inicial del modelo
- Significados específicos del contexto de palabras comunes cuando se usan en entornos técnicos
- Acrónimos y abreviaturas específicas de la industria que pueden tener múltiples interpretaciones

Para abordar estos desafíos de vocabulario, se pueden emplear varias técnicas especializadas:

Enfoques de Solución
- Adaptación de dominio mediante pre-entrenamiento continuo en corpus específicos del campo
- Estrategias de tokenización personalizadas que manejan mejor términos técnicos
- Aumento de vocabulario especializado durante el ajuste fino
- Integración de bases de conocimiento y ontologías específicas del dominio

6.3.5 Puntos Clave

La clasificación de texto es una tarea versátil de PLN con amplias aplicaciones en diferentes industrias. En servicio al cliente, ayuda a categorizar y enrutar tickets de soporte de manera eficiente. En moderación de contenido, identifica contenido inapropiado y spam. Para organizaciones de medios, permite la categorización automática de noticias y etiquetado de contenido. Las instituciones financieras la utilizan para análisis de sentimiento de informes de mercado y clasificación automatizada de documentos.
Los Transformers como BERT y RoBERTa han revolucionado la clasificación de texto a través de su arquitectura sofisticada. Su mecanismo de auto-atención les permite capturar dependencias de largo alcance en el texto, mientras que su procesamiento bidireccional asegura una comprensión integral del contexto. El pre-entrenamiento en corpus masivos de texto permite que estos modelos aprendan representaciones ricas del lenguaje, que luego pueden aplicarse efectivamente a tareas específicas de clasificación.
El ajuste fino en conjuntos de datos específicos del dominio es crucial para optimizar el rendimiento del transformer. Este proceso implica adaptar cuidadosamente el modelo pre-entrenado para comprender la terminología, convenciones y matices específicos de la industria. Por ejemplo, un clasificador de texto médico necesita reconocer terminología especializada, mientras que un clasificador de documentos legales debe comprender lenguaje legal complejo. Esta adaptabilidad hace que los transformers sean adecuados para diversas aplicaciones, desde la clasificación de artículos científicos hasta el análisis de contenido en redes sociales.
La implementación y despliegue exitosos de sistemas de clasificación de texto requieren una atención meticulosa a varios factores. La calidad del conjunto de datos debe garantizarse mediante una cuidadosa curación y limpieza de los datos de entrenamiento. Los pasos de preprocesamiento, como la normalización de texto y tokenización, deben optimizarse para el caso de uso específico. La evaluación del modelo debe incluir métricas integrales más allá de la precisión, como la precisión, recuperación y puntuación F1, particularmente para conjuntos de datos desequilibrados. El monitoreo y las actualizaciones regulares son esenciales para mantener el rendimiento a lo largo del tiempo.

6.3 Clasificación de Texto

Las aplicaciones de la clasificación de texto abarcan diversos campos y casos de uso, incluyendo:

Detección de Spam: Más allá de la simple categorización "spam" o "no spam", los sistemas modernos analizan múltiples aspectos de los correos electrónicos, incluyendo patrones de contenido, reputación del remitente y señales contextuales para proteger a los usuarios de comunicaciones no deseadas o maliciosas.
Clasificación por Temas: Los sistemas avanzados ahora pueden categorizar contenido a través de cientos de temas y subtemas, permitiendo una organización precisa del contenido en agregadores de noticias, sistemas de gestión de contenido y bases de datos de investigación. Los ejemplos se extienden más allá de deportes y política para incluir temas técnicos, disciplinas académicas y temas emergentes.
Análisis de Sentimiento: El análisis de sentimiento moderno va más allá de las clasificaciones básicas positivo/negativo/neutral para detectar matices emocionales sutiles, sarcasmo y opiniones dependientes del contexto. Esto permite a las empresas obtener percepciones más profundas sobre el feedback de los clientes y las reacciones en redes sociales.
Reconocimiento de Intención: Los sistemas contemporáneos de reconocimiento de intención pueden identificar intenciones complejas del usuario en IA conversacional, incluyendo solicitudes de múltiples pasos, intenciones implícitas y consultas dependientes del contexto. Esta capacidad es crucial para crear interacciones humano-computadora más naturales y efectivas.

6.3.1 ¿Por qué usar Transformers para la clasificación de texto?

Los Transformers han revolucionado la clasificación de texto al ofrecer varias ventajas revolucionarias:

Comprensión Contextual

Captar el significado matizado de las palabras basándose en su contexto circundante - Por ejemplo, entender que "banco" significa una institución financiera cuando se usa cerca de palabras como "dinero" o "cuenta", pero significa la orilla de un río cuando se usa cerca de palabras como "río" o "corriente"
Comprender dependencias de largo alcance entre oraciones - El modelo puede conectar conceptos relacionados incluso cuando aparecen separados por varias oraciones, de manera similar a cómo los humanos mantienen el contexto durante una conversación
Reconocer patrones lingüísticos sutiles y modismos - En lugar de tomar las frases literalmente, los Transformers pueden entender el lenguaje figurado y expresiones comunes analizando cómo estas frases se utilizan típicamente en contexto
Manejar la ambigüedad considerando el contexto completo de uso - Cuando se encuentran con palabras o frases que podrían tener múltiples significados, el modelo evalúa todo el contexto para determinar la interpretación más apropiada, similar a cómo los humanos resuelven la ambigüedad en la conversación natural

Aprendizaje por Transferencia

Reduce la necesidad de grandes conjuntos de datos de entrenamiento específicos para cada tarea
- Los enfoques tradicionales de aprendizaje automático a menudo requerían decenas de miles de ejemplos etiquetados
- El aprendizaje por transferencia puede lograr excelentes resultados con solo cientos de ejemplos
- Particularmente valioso para dominios especializados donde los datos etiquetados son escasos
Preserva la comprensión general del lenguaje mientras se adapta a dominios específicos
- Mantiene un amplio conocimiento de patrones y estructuras del lenguaje
- Se adapta exitosamente a terminología y convenciones específicas del dominio
- Equilibra efectivamente el conocimiento general y especializado
Permite una implementación rápida para nuevos casos de uso
- Reduce significativamente el tiempo de desarrollo comparado con el entrenamiento desde cero
- Permite una adaptación rápida a requisitos emergentes
- Facilita la mejora iterativa y la experimentación
Logra un rendimiento estado del arte con un entrenamiento específico mínimo
- A menudo supera a los modelos tradicionales entrenados desde cero
- Requiere menos tiempo de ajuste fino y recursos computacionales
- Demuestra una generalización superior a nuevos ejemplos

Versatilidad

Salud: Procesamiento de registros médicos y artículos de investigación, incluyendo terminología compleja, diagnósticos, protocolos de tratamiento y datos de ensayos clínicos. Estos modelos pueden identificar entidades médicas clave y relaciones mientras mantienen los estándares de privacidad del paciente.
Finanzas: Análisis de informes de mercado y documentos financieros, desde informes trimestrales de ganancias hasta evaluaciones de riesgo. Pueden procesar terminología financiera compleja, datos numéricos y requisitos de cumplimiento regulatorio mientras comprenden el contexto específico del mercado.
Servicio al Cliente: Comprensión de consultas y retroalimentación de clientes a través de múltiples canales, incluyendo correos electrónicos, registros de chat y redes sociales. Pueden detectar el sentimiento del cliente, la urgencia y la intención mientras manejan múltiples idiomas y estilos de comunicación.
Legal: Procesamiento de documentos legales y jurisprudencia, incluyendo contratos, patentes y decisiones judiciales. Estos modelos pueden comprender terminología legal compleja, precedentes y variaciones jurisdiccionales mientras mantienen la precisión en interpretaciones legales sensibles.

6.3.2 Pasos para la Clasificación de Texto con Transformers

1. Preparación de Datos

Limpieza y Estandarización

Eliminar caracteres irrelevantes, símbolos especiales y espacios en blanco innecesarios
- Eliminar etiquetas HTML y artefactos de formato
- Eliminar o reemplazar caracteres no imprimibles
- Estandarizar caracteres Unicode y codificaciones
Manejar valores faltantes e inconsistencias en el texto
- Identificar y manejar valores NULL apropiadamente
- Tratar con entradas de texto truncadas o corruptas
- Estandarizar patrones de formato inconsistentes
Normalizar texto (ej., minúsculas, eliminar acentos)
- Convertir todo el texto a un formato consistente (típicamente minúsculas)
- Eliminar o estandarizar marcas diacríticas
- Estandarizar puntuación y espaciado
Dividir datos en conjuntos de entrenamiento, validación y prueba
- Típicamente usar 70-80% para entrenamiento
- 10-15% para validación durante el desarrollo del modelo
- 10-15% para pruebas finales y evaluación
- Asegurar una distribución equilibrada de clases entre las divisiones

Ejemplo: Pipeline de Preparación de Datos

import pandas as pd
import re
from sklearn.model_selection import train_test_split

def clean_text(text):
    # Remove HTML tags
    text = re.sub(r'<[^>]+>', '', text)
    
    # Remove special characters and digits
    text = re.sub(r'[^a-zA-Z\s]', '', text)
    
    # Convert to lowercase
    text = text.lower()
    
    # Remove extra whitespace
    text = ' '.join(text.split())
    
    return text

# Load raw data
df = pd.read_csv('raw_data.csv')

# Clean text data
df['cleaned_text'] = df['text'].apply(clean_text)

# Split data while maintaining class distribution
train_data, temp_data = train_test_split(
    df, 
    test_size=0.3,
    stratify=df['label'],
    random_state=42
)

# Split temp data into validation and test sets
val_data, test_data = train_test_split(
    temp_data,
    test_size=0.5,
    stratify=temp_data['label'],
    random_state=42
)

print(f"Training samples: {len(train_data)}")
print(f"Validation samples: {len(val_data)}")
print(f"Test samples: {len(test_data)}")

Aquí está el desglose de sus componentes principales:

Importaciones y Configuración

Utiliza pandas para el manejo de datos, re para expresiones regulares y sklearn para la división de datos

Función de Limpieza de Texto

La función clean_text() realiza varios pasos de preprocesamiento:

Elimina etiquetas HTML
Elimina caracteres especiales y dígitos
Convierte el texto a minúsculas
Elimina espacios en blanco extra

Carga y Limpieza de Datos

Carga datos desde un archivo CSV
Aplica la función de limpieza a la columna de texto

División de Datos

El código implementa una división en dos etapas de los datos:

Primera división: 70% entrenamiento, 30% datos temporales
Segunda división: Los datos temporales se dividen equitativamente entre conjuntos de validación y prueba
Utiliza estratificación para mantener la distribución de clases en todas las divisiones

Resultados

La distribución final del conjunto de datos:

Conjunto de entrenamiento: 7,000 muestras
Conjunto de validación: 1,500 muestras
Conjunto de prueba: 1,500 muestras

Esta división sigue la práctica recomendada de usar 70-80% para entrenamiento y 10-15% cada uno para validación y pruebas.

Salida Esperada:

Training samples: 7000
Validation samples: 1500
Test samples: 1500

2. Selección del Modelo: Consideraciones Clave

La elección de un modelo Transformer pre-entrenado apropiado requiere una evaluación cuidadosa de varios factores críticos:

Considerar factores como el tamaño del modelo, requisitos computacionales y soporte de idiomas:
- El tamaño del modelo afecta el uso de memoria y la velocidad de inferencia
- Los requisitos de GPU/CPU impactan los costos de implementación
- El soporte de idiomas determina las capacidades multilingües
Las opciones populares incluyen:
- BERT: Excelente para tareas de clasificación de propósito general
- RoBERTa: Versión mejorada de BERT con entrenamiento optimizado
- DistilBERT: Variante más ligera y rápida, ideal para restricciones de recursos
- XLNet: Modelo avanzado mejor en el manejo de dependencias de largo alcance
Evaluar el equilibrio entre la complejidad del modelo y las necesidades de rendimiento:
- Los modelos más grandes generalmente ofrecen mejor precisión pero inferencia más lenta
- Los modelos más pequeños proporcionan procesamiento más rápido pero pueden sacrificar algo de precisión
- Considerar los requisitos y restricciones específicos de tu caso de uso

Ejemplo: Guía de Selección de Modelo

from transformers import AutoModelForSequenceClassification, AutoTokenizer

def select_model(task_requirements):
    if task_requirements['computational_resources'] == 'limited':
        # Lightweight model for resource-constrained environments
        model_name = "distilbert-base-uncased"
        max_length = 256
    elif task_requirements['language'] == 'multilingual':
        # Multilingual model for cross-language tasks
        model_name = "xlm-roberta-base"
        max_length = 512
    else:
        # Full-size model for maximum accuracy
        model_name = "roberta-large"
        max_length = 512
    
    # Load model and tokenizer
    model = AutoModelForSequenceClassification.from_pretrained(model_name)
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    
    return model, tokenizer, max_length

# Example usage
requirements = {
    'computational_resources': 'limited',
    'language': 'english',
    'task': 'sentiment_analysis'
}

model, tokenizer, max_length = select_model(requirements)
print(f"Selected model: {model.config.model_type}")
print(f"Model parameters: {model.num_parameters():,}")
print(f"Maximum sequence length: {max_length}")

Aquí está el desglose de sus componentes principales:

Definición de la Función:

La función select_model elige un modelo pre-entrenado apropiado basado en requisitos específicos de la tarea:

Para recursos computacionales limitados: Utiliza DistilBERT (un modelo ligero) con longitud de secuencia de 256
Para tareas multilingües: Utiliza XLM-RoBERTa con longitud de secuencia de 512
Para máxima precisión: Utiliza RoBERTa-large con longitud de secuencia de 512

Lógica de Selección del Modelo:

La función considera tres factores principales:

Tamaño del modelo y uso de memoria
Requisitos de GPU/CPU
Capacidades de soporte de idiomas

Ejemplo de Implementación:

El código incluye un ejemplo práctico usando estos requisitos:

Recursos computacionales limitados
Idioma inglés
Tarea de análisis de sentimiento

En este caso, selecciona DistilBERT como modelo, que se muestra en la salida con aproximadamente 66 millones de parámetros y una longitud máxima de secuencia de 256.

Esta implementación permite una selección flexible del modelo mientras equilibra el compromiso entre la complejidad del modelo y las necesidades de rendimiento.

Salida Esperada:

Selected model: distilbert
Model parameters: 66,362,880
Maximum sequence length: 256

3. Tokenización

El proceso de tokenización implica varios pasos clave:

Dividir el texto en unidades más pequeñas:
- Palabras: Dividir el texto en los límites de las palabras (ej., "hola mundo" → ["hola", "mundo"])
- Subpalabras: Dividir palabras complejas en partes significativas (ej., "jugando" → ["jug", "##ando"])
- Caracteres: En algunos casos, dividir el texto en caracteres individuales para un procesamiento más granular
Aplicar reglas de tokenización específicas del modelo:
- WordPiece (BERT): Divide las palabras en unidades de subpalabras comunes
- BPE (GPT): Utiliza codificación por pares de bytes para encontrar pares de tokens comunes
- SentencePiece: Trata el texto como una secuencia de caracteres unicode
Manejar tokens especiales que tienen funciones específicas:
- [CLS]: Token de clasificación, usado para tareas a nivel de oración
- [SEP]: Token separador, marca los límites entre oraciones
- [PAD]: Tokens de relleno, usados para mantener longitudes de entrada consistentes
- [MASK]: Usado en el modelado de lenguaje enmascarado durante el pre-entrenamiento

Ejemplo: Implementación de Tokenización

from transformers import AutoTokenizer

def demonstrate_tokenization(text):
    # Initialize tokenizer (using BERT as example)
    tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
    
    # Basic tokenization
    tokens = tokenizer.tokenize(text)
    
    # Convert tokens to ids
    input_ids = tokenizer.convert_tokens_to_ids(tokens)
    
    # Create attention mask
    attention_mask = [1] * len(input_ids)
    
    # Add special tokens and pad sequence
    encoded = tokenizer(
        text,
        padding='max_length',
        truncation=True,
        max_length=128,
        return_tensors='pt'
    )
    
    return {
        'original_text': text,
        'tokens': tokens,
        'input_ids': input_ids,
        'encoded': encoded
    }

# Example usage
text = "The quick brown fox jumps over the lazy dog!"
result = demonstrate_tokenization(text)

print("Original text:", result['original_text'])
print("\nTokens:", result['tokens'])
print("\nInput IDs:", result['input_ids'])
print("\nFull encoding:", result['encoded'])

Analicemos lo que está sucediendo en este ejemplo:

Proceso de Tokenización:
- El tokenizador primero divide el texto en tokens usando la tokenización WordPiece
- Algunas palabras se dividen en subpalabras (por ejemplo, "jumps" → ["jump", "##s"])
- Se añaden tokens especiales ([CLS] al inicio, [SEP] al final)
Componentes Clave:
- input_ids: Representaciones numéricas de los tokens
- attention_mask: Indica qué tokens son de relleno (0) vs. tokens reales (1)
- La salida codificada incluye tensores listos para la entrada del modelo

Este ejemplo muestra cómo el texto sin procesar se transforma en un formato que los modelos Transformer pueden procesar, incluyendo el manejo de tokens especiales, relleno y máscaras de atención.

Salida Esperada:

Original text: The quick brown fox jumps over the lazy dog!

Tokens: ['the', 'quick', 'brown', 'fox', 'jump', '##s', 'over', 'the', 'lazy', 'dog', '!']

Input IDs: [1996, 4248, 2829, 4419, 4083, 2015, 2058, 1996, 3910, 3899, 999]

Full encoding: {
    'input_ids': tensor([[  101,  1996,  4248,  2829,  4419,  4083,  2015,  2058,  1996,  3910,
                           3899,   999,   102,     0,     0, ...]),
    'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, ...]])
}

4. Ajuste fino (opcional): Adaptación y Optimización del Modelo

El ajuste fino implica adaptar un modelo pre-entrenado a tu caso de uso específico mediante el ajuste cuidadoso de parámetros y la configuración del entrenamiento. Este proceso requiere:

Ajustar los parámetros del modelo usando datos etiquetados específicos del dominio:
- Seleccionar cuidadosamente ejemplos de entrenamiento representativos de tu dominio
- Equilibrar las distribuciones de clases para prevenir sesgos
- Considerar la aumentación de datos para conjuntos de datos limitados
Configurar la tasa de aprendizaje, tamaño de lote y número de épocas de entrenamiento:
- Comenzar con una tasa de aprendizaje pequeña (típicamente 2e-5 a 5e-5) para prevenir el olvido catastrófico
- Elegir el tamaño de lote basado en la memoria disponible y recursos computacionales
- Determinar el número óptimo de épocas mediante el rendimiento de validación
Implementar parada temprana y puntos de control del modelo:
- Monitorear métricas de validación para prevenir el sobreajuste
- Guardar los estados del modelo con mejor rendimiento durante el entrenamiento
- Usar callbacks para detener automáticamente el entrenamiento cuando el rendimiento se estabiliza

Ejemplo: Implementación del Ajuste Fino

from transformers import AutoModelForSequenceClassification, AutoTokenizer, Trainer, TrainingArguments
import torch
from torch.utils.data import Dataset
import numpy as np
from sklearn.metrics import accuracy_score, precision_recall_fscore_support

# Custom dataset class
class CustomDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_length=128):
        self.encodings = tokenizer(texts, truncation=True, padding=True, max_length=max_length)
        self.labels = labels

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

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

# 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='weighted')
    acc = accuracy_score(labels, preds)
    return {
        'accuracy': acc,
        'f1': f1,
        'precision': precision,
        'recall': recall
    }

def fine_tune_model(train_texts, train_labels, val_texts, val_labels):
    # Initialize tokenizer and model
    tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
    model = AutoModelForSequenceClassification.from_pretrained(
        'bert-base-uncased',
        num_labels=len(set(train_labels))
    )

    # Create datasets
    train_dataset = CustomDataset(train_texts, train_labels, tokenizer)
    val_dataset = CustomDataset(val_texts, val_labels, tokenizer)

    # Define training arguments
    training_args = TrainingArguments(
        output_dir='./results',
        num_train_epochs=3,
        per_device_train_batch_size=16,
        per_device_eval_batch_size=64,
        warmup_steps=500,
        weight_decay=0.01,
        logging_dir='./logs',
        logging_steps=10,
        evaluation_strategy="epoch",
        save_strategy="epoch",
        load_best_model_at_end=True,
        metric_for_best_model="f1"
    )

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

    # Train the model
    trainer.train()
    
    return model, tokenizer

# Example usage
train_texts = [
    "This product is amazing!",
    "Terrible service, would not recommend",
    "Neutral experience overall"
]
train_labels = [1, 0, 2]  # 1: positive, 0: negative, 2: neutral
val_texts = [
    "Great purchase, very satisfied",
    "Disappointing quality"
]
val_labels = [1, 0]

model, tokenizer = fine_tune_model(train_texts, train_labels, val_texts, val_labels)

Este ejemplo demuestra un proceso integral de ajuste fino que incorpora varios componentes esenciales para un entrenamiento óptimo del modelo:

Implementación de Conjunto de Datos Personalizado:
- Crea una clase de conjunto de datos especializada que maneja eficientemente tanto datos de texto como sus etiquetas correspondientes
- Implementa la interfaz Dataset de PyTorch para una integración fluida con los ciclos de entrenamiento
- Gestiona el procesamiento por lotes y la eficiencia de memoria
Cálculo Robusto de Métricas:
- Implementa métricas de evaluación completas incluyendo precisión, exactitud, recuperación y puntuación F1
- Permite el monitoreo en tiempo real del rendimiento del modelo durante el entrenamiento
- Facilita la comparación y selección de modelos
Configuración Avanzada de Entrenamiento con Mejores Prácticas de la Industria:
- Calentamiento de la Tasa de Aprendizaje: Aumenta gradualmente la tasa de aprendizaje durante los pasos iniciales de entrenamiento para prevenir gradientes inestables y asegurar una convergencia suave
- Decaimiento de Pesos: Implementa regularización L2 para prevenir el sobreajuste y mejorar la generalización del modelo
- Evaluación Estratégica: Realiza evaluaciones periódicas del modelo en datos de validación para seguir el progreso del entrenamiento
- Sistema de Puntos de Control: Guarda estados del modelo en intervalos regulares para permitir la recuperación y selección de parámetros óptimos
- Selección Inteligente de Modelo: Utiliza la puntuación F1 como la métrica principal para seleccionar la mejor versión del modelo durante el entrenamiento

Registro de Salida Esperado:

{'train_runtime': '2:34:15',
 'train_samples_per_second': 8.123,
 'train_steps_per_second': 0.508,
 'train_loss': 0.1234,
 'epoch': 3.0,
 'eval_loss': 0.2345,
 'eval_accuracy': 0.89,
 'eval_f1': 0.88,
 'eval_precision': 0.87,
 'eval_recall': 0.86}

5. Inferencia: Realizando Predicciones en el Mundo Real

La etapa de inferencia es donde tu modelo entrenado se pone en uso práctico realizando predicciones sobre datos de texto nuevos y no vistos. Este proceso involucra varios pasos críticos:

Preprocesar nuevos datos usando el mismo pipeline que los datos de entrenamiento:
- Aplicar pasos idénticos de limpieza y normalización de texto
- Usar el mismo enfoque de tokenización y vocabulario
- Asegurar un manejo consistente de caracteres especiales y formato
Generar predicciones con puntuaciones de confianza:
- Ejecutar el texto preprocesado a través del modelo
- Obtener distribuciones de probabilidad entre las clases posibles
- Aplicar criterios de umbral para la toma de decisiones
Post-procesar resultados para interpretación y uso:
- Convertir las salidas del modelo a formato legible por humanos
- Aplicar reglas de negocio o filtrado si es necesario
- Formatear resultados para integración con sistemas posteriores

Ejemplo: Pipeline Completo de Inferencia

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import numpy as np

class TextClassificationPipeline:
    def __init__(self, model_name='bert-base-uncased', device='cuda' if torch.cuda.is_available() else 'cpu'):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
        self.device = device
        self.model.to(device)
        self.model.eval()
        
    def preprocess(self, text):
        # Clean and normalize text
        text = text.lower().strip()
        
        # Tokenize
        encoded = self.tokenizer(
            text,
            truncation=True,
            padding=True,
            max_length=512,
            return_tensors='pt'
        )
        
        return {k: v.to(self.device) for k, v in encoded.items()}
    
    def predict(self, text, threshold=0.5):
        # Preprocess input
        inputs = self.preprocess(text)
        
        # Run inference
        with torch.no_grad():
            outputs = self.model(**inputs)
            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
        
        # Get predictions
        predictions = probabilities.cpu().numpy()
        
        # Post-process results
        result = {
            'label': self.model.config.id2label[predictions.argmax()],
            'confidence': float(predictions.max()),
            'all_probabilities': {
                self.model.config.id2label[i]: float(p)
                for i, p in enumerate(predictions[0])
            }
        }
        
        # Apply threshold if specified
        result['above_threshold'] = result['confidence'] >= threshold
        
        return result

def batch_inference(texts, pipeline, batch_size=32):
    results = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        batch_results = [pipeline.predict(text) for text in batch]
        results.extend(batch_results)
    return results

# Example usage
if __name__ == "__main__":
    # Initialize pipeline
    pipeline = TextClassificationPipeline()
    
    # Example texts
    texts = [
        "This product exceeded all my expectations!",
        "The customer service was absolutely horrible.",
        "The package arrived on time, as expected."
    ]
    
    # Single prediction
    print("Single Text Inference:")
    result = pipeline.predict(texts[0])
    print(f"Text: {texts[0]}")
    print(f"Prediction: {result}\n")
    
    # Batch prediction
    print("Batch Inference:")
    results = batch_inference(texts, pipeline)
    for text, result in zip(texts, results):
        print(f"Text: {text}")
        print(f"Prediction: {result}\n")

Aquí está el desglose de sus componentes principales:

Clase TextClassificationPipeline

Se inicializa con un modelo pre-entrenado (por defecto BERT) y gestiona la configuración del dispositivo (CPU/GPU)
Incluye preprocesamiento que normaliza el texto y maneja la tokenización con una longitud máxima de 512 tokens
Implementa funcionalidad de predicción con puntuación de confianza y filtrado basado en umbrales

Métodos Principales

preprocess(): Limpia el texto y lo convierte a un formato compatible con el modelo
predict(): Maneja la predicción de texto individual con una salida completa que incluye:
- Predicción de etiqueta
- Puntuación de confianza
- Distribución de probabilidad entre todas las clases posibles
batch_inference(): Procesa múltiples textos eficientemente en lotes de 32

Formato de Salida

Devuelve predicciones estructuradas con:
- Etiqueta predicha
- Puntuación de confianza
- Distribución completa de probabilidad
- Resultado de verificación de umbral

Salida Esperada:

Single Text Inference:
Text: This product exceeded all my expectations!
Prediction: {
    'label': 'POSITIVE',
    'confidence': 0.97,
    'all_probabilities': {
        'NEGATIVE': 0.01,
        'NEUTRAL': 0.02,
        'POSITIVE': 0.97
    },
    'above_threshold': True
}

Batch Inference:
Text: This product exceeded all my expectations!
Prediction: {
    'label': 'POSITIVE',
    'confidence': 0.97,
    'all_probabilities': {...}
    'above_threshold': True
}

Text: The customer service was absolutely horrible.
Prediction: {
    'label': 'NEGATIVE',
    'confidence': 0.95,
    'all_probabilities': {...}
    'above_threshold': True
}

Text: The package arrived on time, as expected.
Prediction: {
    'label': 'NEUTRAL',
    'confidence': 0.88,
    'all_probabilities': {...}
    'above_threshold': True
}

6.3.3 Aplicaciones de la Clasificación de Texto

1. Detección de Spam

Análisis del contenido del mensaje: Examen de patrones de texto, frecuencias de palabras clave y características lingüísticas
Patrones de comportamiento del remitente: Evaluación de la frecuencia de envío, patrones temporales y reputación histórica del remitente
Metadatos técnicos: Análisis de encabezados de correo, direcciones IP, registros de autenticación e información de enrutamiento
Análisis de archivos adjuntos: Escaneo de tipos de archivo sospechosos y contenido malicioso

Los sistemas modernos de detección de spam emplean técnicas avanzadas para identificar varios tipos de comunicaciones no deseadas:

Intentos sofisticados de phishing utilizando ingeniería social
Campañas dirigidas de spear-phishing
Correos masivos de marketing que violan regulaciones
Intentos de distribución de malware
Estafas de compromiso de correo empresarial (BEC)

Estos sistemas aprenden y se adaptan continuamente a nuevas amenazas, ayudando a mantener la seguridad y organización del buzón mediante:

Detección y bloqueo de amenazas en tiempo real
Filtrado adaptativo basado en retroalimentación del usuario
Integración con redes globales de inteligencia de amenazas
Cuarentena y clasificación automatizada de mensajes sospechosos

Ejemplo: Sistema Integral de Detección de Spam

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import re
from typing import List, Dict
import numpy as np

class SpamDetectionSystem:
    def __init__(self, model_name: str = 'bert-base-uncased', threshold: float = 0.5):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
        self.threshold = threshold
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        self.model.to(self.device)
        
    def preprocess_text(self, text: str) -> str:
        """Clean and normalize text input"""
        # Convert to lowercase
        text = text.lower()
        # Remove URLs
        text = re.sub(r'http\S+|www\S+|https\S+', '', text)
        # Remove email addresses
        text = re.sub(r'\S+@\S+', '', text)
        # Remove special characters
        text = re.sub(r'[^\w\s]', '', text)
        # Remove extra whitespace
        text = ' '.join(text.split())
        return text
    
    def extract_features(self, text: str) -> Dict:
        """Extract additional spam-indicative features"""
        features = {
            'contains_urgent': bool(re.search(r'urgent|immediate|act now', text.lower())),
            'contains_money': bool(re.search(r'[$€£]\d+|\d+[$€£]|money|cash', text.lower())),
            'excessive_caps': len(re.findall(r'[A-Z]{3,}', text)) > 2,
            'text_length': len(text.split()),
        }
        return features
    
    def predict(self, text: str) -> Dict:
        """Perform spam detection on a single text"""
        # Preprocess text
        cleaned_text = self.preprocess_text(text)
        
        # Extract additional features
        features = self.extract_features(text)
        
        # Tokenize
        inputs = self.tokenizer(
            cleaned_text,
            truncation=True,
            padding=True,
            max_length=512,
            return_tensors='pt'
        ).to(self.device)
        
        # Get model prediction
        self.model.eval()
        with torch.no_grad():
            outputs = self.model(**inputs)
            probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
            spam_probability = float(probabilities[0][1].cpu())
        
        # Combine model prediction with rule-based features
        final_score = spam_probability
        if features['contains_urgent'] and features['contains_money']:
            final_score += 0.1
        if features['excessive_caps']:
            final_score += 0.05
            
        return {
            'is_spam': final_score >= self.threshold,
            'spam_probability': final_score,
            'features': features,
            'original_text': text,
            'cleaned_text': cleaned_text
        }
    
    def batch_predict(self, texts: List[str], batch_size: int = 32) -> List[Dict]:
        """Process multiple texts in batches"""
        results = []
        for i in range(0, len(texts), batch_size):
            batch = texts[i:i + batch_size]
            batch_results = [self.predict(text) for text in batch]
            results.extend(batch_results)
        return results

# Example usage
if __name__ == "__main__":
    # Initialize spam detector
    spam_detector = SpamDetectionSystem()
    
    # Example messages
    messages = [
        "Hey! How are you doing?",
        "URGENT! You've won $10,000,000! Send bank details NOW!!!",
        "Meeting scheduled for tomorrow at 2 PM",
        "FREE VIAGRA! Best prices! Click here NOW!!!"
    ]
    
    # Process messages
    results = spam_detector.batch_predict(messages)
    
    # Display results
    for msg, result in zip(messages, results):
        print(f"\nMessage: {msg}")
        print(f"Spam Probability: {result['spam_probability']:.2f}")
        print(f"Is Spam: {result['is_spam']}")
        print(f"Features: {result['features']}")

Desglose del Código:

Componentes Principales:
- Modelo basado en Transformers para análisis profundo de texto
- Extracción de características basada en reglas para señales adicionales
- Pipeline integral de preprocesamiento de texto
- Capacidades de procesamiento por lotes para eficiencia
Características Clave:
- Enfoque híbrido que combina ML y detección basada en reglas
- Limpieza y normalización exhaustiva de texto
- Extracción adicional de indicadores de spam
- Umbral de spam configurable
Capacidades Avanzadas:
- Soporte de aceleración GPU para procesamiento más rápido
- Procesamiento por lotes para manejar múltiples mensajes
- Informes detallados de predicción con análisis de características
- Sistema de puntuación personalizable que combina múltiples señales

2. Análisis de Retroalimentación del Cliente

Procesar y categorizar automáticamente la retroalimentación del cliente a través de múltiples dimensiones incluyendo:

Evaluación de Calidad del Producto
- Evaluaciones de rendimiento y durabilidad
- Informes de consistencia de fabricación
- Retroalimentación de funcionalidad de características
Análisis de Precios
- Métricas de percepción de valor
- Comparaciones de precios competitivos
- Retroalimentación sobre la relación precio-características
Evaluación de Experiencia de Servicio
- Calidad de interacción del servicio al cliente
- Mediciones de tiempo de respuesta
- Efectividad en la resolución de problemas
Retroalimentación de Interfaz de Usuario
- Evaluaciones de usabilidad
- Informes de eficiencia de navegación
- Preferencias de diseño y disposición

Este análisis integral permite a las empresas:

Rastrear tendencias emergentes en tiempo real
Identificar áreas específicas que requieren atención inmediata
Priorizar mejoras basadas en el impacto al cliente
Asignar recursos más efectivamente
Desarrollar hojas de ruta de productos basadas en datos

Los sistemas avanzados mejoran este proceso a través de:

Detección Inteligente de Urgencia
- Algoritmos de análisis de sentimientos
- Mecanismos de puntuación de prioridad
- Métricas de evaluación de impacto
Sistemas de Enrutamiento Automatizado
- Asignación de problemas por departamento
- Protocolos de escalamiento
- Optimización de tiempo de respuesta

Ejemplo: Sistema de Análisis Multidimensional de Retroalimentación del Cliente

from transformers import pipeline
import pandas as pd
import numpy as np
from typing import List, Dict, Union
from collections import defaultdict

class CustomerFeedbackAnalyzer:
    def __init__(self):
        # Initialize various analysis pipelines
        self.sentiment_analyzer = pipeline("sentiment-analysis")
        self.zero_shot_classifier = pipeline("zero-shot-classification")
        self.aspect_categories = [
            "product_quality", "pricing", "customer_service",
            "user_interface", "features", "reliability"
        ]
        
    def analyze_feedback(self, text: str) -> Dict[str, Union[str, float, Dict]]:
        """Comprehensive analysis of a single feedback entry"""
        results = {}
        
        # Sentiment Analysis
        sentiment = self.sentiment_analyzer(text)[0]
        results['sentiment'] = {
            'label': sentiment['label'],
            'score': sentiment['score']
        }
        
        # Aspect-based categorization
        aspect_results = self.zero_shot_classifier(
            text,
            candidate_labels=self.aspect_categories,
            multi_label=True
        )
        
        # Filter aspects with confidence > 0.3
        results['aspects'] = {
            label: score for label, score in 
            zip(aspect_results['labels'], aspect_results['scores'])
            if score > 0.3
        }
        
        # Extract key metrics
        results['metrics'] = self._extract_metrics(text)
        
        # Priority scoring
        results['priority_score'] = self._calculate_priority(
            results['sentiment'],
            results['aspects']
        )
        
        return results
    
    def _extract_metrics(self, text: str) -> Dict[str, Union[int, float]]:
        """Extract numerical metrics from feedback"""
        metrics = {
            'word_count': len(text.split()),
            'avg_word_length': np.mean([len(word) for word in text.split()]),
            'contains_rating': bool(re.search(r'\d+/\d+|\d+\s*stars?', text.lower()))
        }
        return metrics
    
    def _calculate_priority(self, sentiment: Dict, aspects: Dict) -> float:
        """Calculate priority score based on sentiment and aspects"""
        # Base priority on sentiment
        priority = 0.5  # Default medium priority
        
        # Adjust based on sentiment
        if sentiment['label'] == 'NEGATIVE' and sentiment['score'] > 0.8:
            priority += 0.3
        
        # Adjust based on critical aspects
        critical_aspects = {'customer_service', 'reliability', 'product_quality'}
        for aspect, score in aspects.items():
            if aspect in critical_aspects and score > 0.7:
                priority += 0.1
        
        return min(1.0, priority)  # Cap at 1.0
    
    def batch_analyze(self, feedback_list: List[str]) -> List[Dict]:
        """Process multiple feedback entries"""
        return [self.analyze_feedback(text) for text in feedback_list]
    
    def generate_summary_report(self, feedback_results: List[Dict]) -> Dict:
        """Generate summary statistics from analyzed feedback"""
        summary = {
            'total_feedback': len(feedback_results),
            'sentiment_distribution': defaultdict(int),
            'aspect_frequency': defaultdict(int),
            'priority_levels': {
                'high': 0,
                'medium': 0,
                'low': 0
            }
        }
        
        for result in feedback_results:
            # Count sentiments
            summary['sentiment_distribution'][result['sentiment']['label']] += 1
            
            # Count aspects
            for aspect in result['aspects'].keys():
                summary['aspect_frequency'][aspect] += 1
            
            # Categorize priority
            priority = result['priority_score']
            if priority > 0.7:
                summary['priority_levels']['high'] += 1
            elif priority > 0.3:
                summary['priority_levels']['medium'] += 1
            else:
                summary['priority_levels']['low'] += 1
        
        return summary

# Example usage
if __name__ == "__main__":
    analyzer = CustomerFeedbackAnalyzer()
    
    # Example feedback entries
    feedback_examples = [
        "The new interface is amazing! So much easier to use than before.",
        "Product quality has declined significantly. Customer service was unhelpful.",
        "Decent product but a bit pricey for what you get.",
        "System keeps crashing. This is extremely frustrating!"
    ]
    
    # Analyze feedback
    results = analyzer.batch_analyze(feedback_examples)
    
    # Generate summary report
    summary = analyzer.generate_summary_report(results)
    
    # Print detailed analysis for first feedback
    print("\nDetailed Analysis of First Feedback:")
    print(f"Text: {feedback_examples[0]}")
    print(f"Sentiment: {results[0]['sentiment']}")
    print(f"Aspects: {results[0]['aspects']}")
    print(f"Priority Score: {results[0]['priority_score']}")
    
    # Print summary statistics
    print("\nSummary Report:")
    print(f"Total Feedback Analyzed: {summary['total_feedback']}")
    print(f"Sentiment Distribution: {dict(summary['sentiment_distribution'])}")
    print(f"Priority Levels: {summary['priority_levels']}")

Desglose del Código:

Componentes Principales:
- Múltiples canales de análisis para diferentes aspectos de la retroalimentación
- Análisis integral de retroalimentación que abarca sentimiento, aspectos y métricas
- Sistema de puntuación de prioridad para clasificación de retroalimentación
- Capacidades de procesamiento por lotes para mayor eficiencia
Características Clave:
- Análisis multidimensional que incorpora clasificación basada en sentimientos y aspectos
- Categorización flexible de aspectos utilizando clasificación de tipo zero-shot
- Extracción de métricas para análisis cuantitativo
- Puntuación de prioridad basada en múltiples factores
Capacidades Avanzadas:
- Análisis detallado de retroalimentación individual
- Procesamiento por lotes para múltiples entradas de retroalimentación
- Generación de informes resumidos con estadísticas clave
- Categorías de aspectos y puntuación de prioridad personalizables

Esta implementación proporciona una base sólida para analizar la retroalimentación del cliente, permitiendo a las empresas:

Identificar tendencias y patrones en el sentimiento del cliente
Priorizar problemas urgentes que requieren atención inmediata
Realizar seguimiento del rendimiento en diferentes aspectos de productos/servicios
Generar conclusiones accionables a partir de datos de retroalimentación del cliente

3. Categorización de Temas

Análisis Semántico
- Comprensión del significado profundo del texto más allá de las palabras clave
- Reconocimiento de relaciones entre conceptos
- Identificación de patrones temáticos entre documentos
Métodos de Clasificación
- Categorización jerárquica para temas anidados
- Clasificación multi-etiqueta para contenido que abarca múltiples categorías
- Adaptación dinámica de categorías basada en tendencias emergentes

Publicación Académica
- Clasificación de trabajos de investigación por campo y subcampo
- Etiquetado automático de artículos científicos
Medios y Publicación
- Categorización de noticias en tiempo real
- Curación de contenido para plataformas digitales
Plataformas en Línea
- Moderación de contenido generado por usuarios
- Organización automatizada de contenido

from transformers import pipeline
from sklearn.preprocessing import MultiLabelBinarizer
from typing import List, Dict, Union
import numpy as np
from collections import defaultdict

class TopicCategorizer:
    def __init__(self, threshold: float = 0.3):
        # Initialize zero-shot classification pipeline
        self.classifier = pipeline("zero-shot-classification")
        self.threshold = threshold
        
        # Define hierarchical topic structure
        self.topic_hierarchy = {
            "technology": ["software", "hardware", "ai", "cybersecurity"],
            "business": ["finance", "marketing", "management", "startups"],
            "science": ["physics", "biology", "chemistry", "astronomy"],
            "health": ["medicine", "nutrition", "fitness", "mental_health"]
        }
        
        # Flatten topics for initial classification
        self.main_topics = list(self.topic_hierarchy.keys())
        self.all_subtopics = [
            subtopic for subtopics in self.topic_hierarchy.values()
            for subtopic in subtopics
        ]
        
    def categorize_text(self, text: str) -> Dict[str, Union[List[str], float]]:
        """Perform hierarchical topic categorization on input text"""
        results = {}
        
        # First level: Main topic classification
        main_topic_results = self.classifier(
            text,
            candidate_labels=self.main_topics,
            multi_label=True
        )
        
        # Filter main topics above threshold
        relevant_main_topics = [
            label for label, score in 
            zip(main_topic_results['labels'], main_topic_results['scores'])
            if score > self.threshold
        ]
        
        # Second level: Subtopic classification for relevant main topics
        relevant_subtopics = []
        for main_topic in relevant_main_topics:
            subtopic_candidates = self.topic_hierarchy[main_topic]
            subtopic_results = self.classifier(
                text,
                candidate_labels=subtopic_candidates,
                multi_label=True
            )
            
            # Filter subtopics above threshold
            relevant_subtopics.extend([
                label for label, score in 
                zip(subtopic_results['labels'], subtopic_results['scores'])
                if score > self.threshold
            ])
        
        results['main_topics'] = relevant_main_topics
        results['subtopics'] = relevant_subtopics
        
        # Calculate confidence scores
        results['confidence_scores'] = {
            'main_topics': {
                label: score for label, score in 
                zip(main_topic_results['labels'], main_topic_results['scores'])
                if score > self.threshold
            },
            'subtopics': {
                label: score for label, score in 
                zip(subtopic_results['labels'], subtopic_results['scores'])
                if score > self.threshold
            }
        }
        
        return results
    
    def batch_categorize(self, texts: List[str]) -> List[Dict]:
        """Process multiple texts for categorization"""
        return [self.categorize_text(text) for text in texts]
    
    def generate_topic_report(self, results: List[Dict]) -> Dict:
        """Generate summary statistics from categorization results"""
        report = {
            'total_documents': len(results),
            'main_topic_distribution': defaultdict(int),
            'subtopic_distribution': defaultdict(int),
            'average_confidence': {
                'main_topics': defaultdict(list),
                'subtopics': defaultdict(list)
            }
        }
        
        for result in results:
            # Count topic occurrences
            for topic in result['main_topics']:
                report['main_topic_distribution'][topic] += 1
                
            for subtopic in result['subtopics']:
                report['subtopic_distribution'][subtopic] += 1
            
            # Collect confidence scores
            for topic, score in result['confidence_scores']['main_topics'].items():
                report['average_confidence']['main_topics'][topic].append(score)
                
            for topic, score in result['confidence_scores']['subtopics'].items():
                report['average_confidence']['subtopics'][topic].append(score)
        
        # Calculate average confidence scores
        for topic_level in ['main_topics', 'subtopics']:
            for topic, scores in report['average_confidence'][topic_level].items():
                report['average_confidence'][topic_level][topic] = \
                    np.mean(scores) if scores else 0.0
        
        return report

# Example usage
if __name__ == "__main__":
    categorizer = TopicCategorizer()
    
    # Example texts
    example_texts = [
        "New research shows quantum computers achieving unprecedented processing speeds.",
        "Start-up raises $50M for innovative AI-powered healthcare solutions.",
        "Scientists discover new exoplanet in habitable zone of nearby star."
    ]
    
    # Categorize texts
    results = categorizer.batch_categorize(example_texts)
    
    # Generate summary report
    report = categorizer.generate_topic_report(results)
    
    # Print example results
    print("\nExample Categorization Results:")
    for i, (text, result) in enumerate(zip(example_texts, results)):
        print(f"\nText {i+1}: {text}")
        print(f"Main Topics: {result['main_topics']}")
        print(f"Subtopics: {result['subtopics']}")
        print(f"Confidence Scores: {result['confidence_scores']}")
    
    # Print summary statistics
    print("\nTopic Distribution Summary:")
    print(f"Main Topics: {dict(report['main_topic_distribution'])}")
    print(f"Subtopics: {dict(report['subtopic_distribution'])}")

Desglose del Código:

Componentes Principales:
- Pipeline de clasificación zero-shot para categorización flexible de temas
- Estructura jerárquica de temas que soporta temas principales y subtemas
- Sistema de puntuación de confianza para la asignación de temas
- Capacidades de procesamiento por lotes para múltiples documentos
Características Clave:
- Enfoque de clasificación jerárquica de dos niveles
- Umbral de confianza configurable para la asignación de temas
- Puntuación detallada de confianza tanto para temas principales como subtemas
- Capacidades completas de informes y análisis
Capacidades Avanzadas:
- Clasificación multi-etiqueta que admite asignaciones de múltiples temas
- Jerarquía de temas flexible que puede modificarse fácilmente
- Métricas de rendimiento detalladas y puntuación de confianza
- Procesamiento por lotes escalable para grandes colecciones de documentos

Esta implementación proporciona una base sólida para la categorización de temas, permitiendo:

Organización automática de grandes colecciones de documentos
Sistemas de descubrimiento y recomendación de contenido
Análisis de tendencias en diferentes áreas temáticas
Evaluación de calidad de las asignaciones de temas mediante puntuaciones de confianza

4. Análisis de Sentimientos

Analizar texto para determinar el tono emocional y la actitud expresada por los clientes sobre productos, servicios o marcas. Este análisis sofisticado involucra múltiples capas de comprensión:

Análisis Emocional
- Detección básica de sentimientos (positivo/negativo/neutral)
- Reconocimiento de emociones complejas (alegría, enojo, frustración, entusiasmo)
- Medición de la intensidad de las emociones expresadas
Comprensión Contextual
- Detección de sarcasmo e ironía
- Reconocimiento de sentimientos implícitos
- Comprensión de terminología específica de la industria

Las empresas aprovechan esta profunda perspectiva emocional para múltiples propósitos estratégicos:

Monitoreo de Marca
- Seguimiento en tiempo real de la percepción de marca
- Análisis competitivo
- Detección y gestión de crisis
Desarrollo de Productos
- Priorización de características basada en sentimientos
- Optimización de la experiencia del usuario
- Oportunidades de mejora del producto
Mejora del Servicio al Cliente
- Identificación proactiva de problemas
- Medición de la calidad del servicio
- Seguimiento de la satisfacción del cliente

5. Reconocimiento de Intención

Identificar Intenciones Principales
- Reconocer objetivos principales del usuario (por ejemplo, realizar una compra, buscar información, solicitar soporte)
- Distinguir entre intenciones informativas, transaccionales y de navegación
- Mapear consultas a categorías predefinidas de intención
Manejar la Complejidad de las Consultas
- Procesar solicitudes compuestas con múltiples intenciones integradas
- Comprender intenciones implícitas a partir de pistas contextuales
- Resolver solicitudes ambiguas o poco claras del usuario

Los sistemas avanzados de reconocimiento de intención incorporan conciencia contextual y capacidades de aprendizaje para:

Mantener el Contexto de la Conversación
- Rastrear el historial de conversación para una mejor comprensión
- Considerar las preferencias del usuario e interacciones pasadas
- Adaptar respuestas basadas en el contexto situacional

from transformers import pipeline
from typing import List, Dict, Tuple, Optional
import numpy as np
from dataclasses import dataclass
from collections import defaultdict

@dataclass
class Intent:
    name: str
    confidence: float
    entities: Dict[str, str]

class IntentRecognizer:
    def __init__(self, confidence_threshold: float = 0.6):
        # Initialize zero-shot classification pipeline
        self.classifier = pipeline("zero-shot-classification")
        self.confidence_threshold = confidence_threshold
        
        # Define intent categories and their associated patterns
        self.intent_categories = {
            "purchase": ["buy", "purchase", "order", "get", "acquire"],
            "information": ["what is", "how to", "explain", "tell me about"],
            "support": ["help", "issue", "problem", "not working", "broken"],
            "comparison": ["compare", "difference between", "better than"],
            "availability": ["in stock", "available", "when can I"]
        }
        
        # Entity extraction pipeline
        self.ner_pipeline = pipeline("ner")
        
    def preprocess_text(self, text: str) -> str:
        """Clean and normalize input text"""
        return text.lower().strip()
    
    def extract_entities(self, text: str) -> Dict[str, str]:
        """Extract named entities from text"""
        entities = self.ner_pipeline(text)
        return {
            entity['entity_group']: entity['word']
            for entity in entities
        }
    
    def detect_intent(self, text: str) -> Optional[Intent]:
        """Identify primary intent from user query"""
        processed_text = self.preprocess_text(text)
        
        # Classify intent using zero-shot classification
        result = self.classifier(
            processed_text,
            candidate_labels=list(self.intent_categories.keys()),
            multi_label=False
        )
        
        # Get highest confidence intent
        primary_intent = result['labels'][0]
        confidence = result['scores'][0]
        
        if confidence >= self.confidence_threshold:
            # Extract relevant entities
            entities = self.extract_entities(text)
            
            return Intent(
                name=primary_intent,
                confidence=confidence,
                entities=entities
            )
        return None
    
    def handle_compound_intents(self, text: str) -> List[Intent]:
        """Process text for multiple potential intents"""
        sentences = text.split('.')
        intents = []
        
        for sentence in sentences:
            if sentence.strip():
                intent = self.detect_intent(sentence)
                if intent:
                    intents.append(intent)
        
        return intents
    
    def generate_response(self, intent: Intent) -> str:
        """Generate appropriate response based on detected intent"""
        responses = {
            "purchase": "I can help you make a purchase. ",
            "information": "Let me provide you with information about that. ",
            "support": "I'll help you resolve this issue. ",
            "comparison": "I can help you compare these options. ",
            "availability": "Let me check the availability for you. "
        }
        
        base_response = responses.get(intent.name, "I understand your request. ")
        
        # Add entity-specific information if available
        if intent.entities:
            entity_str = ", ".join(f"{k}: {v}" for k, v in intent.entities.items())
            base_response += f"I see you're interested in: {entity_str}"
        
        return base_response

# Example usage
if __name__ == "__main__":
    recognizer = IntentRecognizer()
    
    # Test cases
    test_queries = [
        "I want to buy a new laptop",
        "Can you explain how cloud computing works?",
        "I'm having problems with my account login",
        "What's the difference between Python and JavaScript?",
        "When will the new iPhone be available?"
    ]
    
    for query in test_queries:
        print(f"\nQuery: {query}")
        intent = recognizer.detect_intent(query)
        if intent:
            print(f"Detected Intent: {intent.name}")
            print(f"Confidence: {intent.confidence:.2f}")
            print(f"Entities: {intent.entities}")
            print(f"Response: {recognizer.generate_response(intent)}")

Desglose del Código:

Componentes Principales:
- Pipeline de clasificación sin ejemplos para reconocimiento flexible de intención
- Pipeline de Reconocimiento de Entidades Nombradas (NER) para extracción de entidades
- Categorías de intención con patrones asociados
- Sistema de generación de respuestas basado en intenciones detectadas
Características Clave:
- Umbral de confianza configurable para detección de intenciones
- Soporte para procesamiento de intenciones compuestas
- Extracción de entidades e integración en respuestas
- Sistema integral de clasificación de intenciones
Capacidades Avanzadas:
- Detección de múltiples intenciones en consultas complejas
- Generación de respuestas contextual
- Personalización de respuestas basada en entidades
- Gestión flexible de categorías de intención

Esta implementación proporciona una base robusta para sistemas de reconocimiento de intención, permitiendo:

Comprensión del lenguaje natural en IA conversacional
Generación automatizada de respuestas de servicio al cliente
Enrutamiento inteligente de consultas de usuarios a los manejadores apropiados
Generación contextual de respuestas basada en intenciones y entidades detectadas

6.3.4 Desafíos en la Clasificación de Texto

Desequilibrio de Clases

Sobreajuste a clases mayoritarias
- Los modelos se vuelven sesgados hacia la predicción de la clase mayoritaria, incluso cuando la evidencia sugiere lo contrario
- Las características aprendidas reflejan principalmente patrones en la clase dominante
- Los límites de clasificación se sesgan hacia características de la clase mayoritaria
Pobre reconocimiento de características de clases minoritarias
- La exposición limitada a ejemplos de clases minoritarias resulta en un aprendizaje débil de características
- Los modelos luchan por identificar patrones distintivos en clases subrepresentadas
- Mayores tasas de clasificación errónea para instancias de clases minoritarias
Probabilidades de predicción sesgadas
- Los puntajes de confianza se vuelven poco fiables debido al sesgo en la distribución de clases
- Los modelos tienden a asignar probabilidades más altas a las clases mayoritarias por defecto
- La toma de decisiones basada en umbrales se vuelve menos efectiva

Para abordar estos desafíos, los profesionales emplean varias soluciones probadas:

Enfoques a nivel de datos:
- Sobremuestreo de clases minoritarias usando técnicas como SMOTE (Técnica de Sobremuestreo de Minorías Sintéticas)
- Submuestreo de clases mayoritarias preservando ejemplos importantes
- Enfoques híbridos combinando tanto sobre como submuestreo
Soluciones a nivel de algoritmo:
- Implementación de funciones de pérdida ponderadas por clase para penalizar más fuertemente los errores de clases minoritarias
- Uso de métodos de conjunto diseñados específicamente para conjuntos de datos desequilibrados
- Aplicación de enfoques de aprendizaje sensibles al costo

Vocabulario Específico del Dominio

Campos técnicos con terminología única
- Terminología médica y jerga - Incluyendo términos anatómicos complejos, nombres de enfermedades, nomenclatura de medicamentos y terminología de procedimientos que raramente aparece en conjuntos de datos de lenguaje general
- Vocabulario científico - Términos especializados de física, química y otras ciencias que tienen significados técnicos precisos
- Terminología legal - Frases y términos legales específicos que tienen significados legales precisos
Desafíos Comunes de Vocabulario
- Palabras fuera del vocabulario (OOV) que no aparecen en los datos de entrenamiento inicial del modelo
- Significados específicos del contexto de palabras comunes cuando se usan en entornos técnicos
- Acrónimos y abreviaturas específicas de la industria que pueden tener múltiples interpretaciones

Para abordar estos desafíos de vocabulario, se pueden emplear varias técnicas especializadas:

Enfoques de Solución
- Adaptación de dominio mediante pre-entrenamiento continuo en corpus específicos del campo
- Estrategias de tokenización personalizadas que manejan mejor términos técnicos
- Aumento de vocabulario especializado durante el ajuste fino
- Integración de bases de conocimiento y ontologías específicas del dominio

6.3.5 Puntos Clave

La clasificación de texto es una tarea versátil de PLN con amplias aplicaciones en diferentes industrias. En servicio al cliente, ayuda a categorizar y enrutar tickets de soporte de manera eficiente. En moderación de contenido, identifica contenido inapropiado y spam. Para organizaciones de medios, permite la categorización automática de noticias y etiquetado de contenido. Las instituciones financieras la utilizan para análisis de sentimiento de informes de mercado y clasificación automatizada de documentos.
Los Transformers como BERT y RoBERTa han revolucionado la clasificación de texto a través de su arquitectura sofisticada. Su mecanismo de auto-atención les permite capturar dependencias de largo alcance en el texto, mientras que su procesamiento bidireccional asegura una comprensión integral del contexto. El pre-entrenamiento en corpus masivos de texto permite que estos modelos aprendan representaciones ricas del lenguaje, que luego pueden aplicarse efectivamente a tareas específicas de clasificación.
El ajuste fino en conjuntos de datos específicos del dominio es crucial para optimizar el rendimiento del transformer. Este proceso implica adaptar cuidadosamente el modelo pre-entrenado para comprender la terminología, convenciones y matices específicos de la industria. Por ejemplo, un clasificador de texto médico necesita reconocer terminología especializada, mientras que un clasificador de documentos legales debe comprender lenguaje legal complejo. Esta adaptabilidad hace que los transformers sean adecuados para diversas aplicaciones, desde la clasificación de artículos científicos hasta el análisis de contenido en redes sociales.
La implementación y despliegue exitosos de sistemas de clasificación de texto requieren una atención meticulosa a varios factores. La calidad del conjunto de datos debe garantizarse mediante una cuidadosa curación y limpieza de los datos de entrenamiento. Los pasos de preprocesamiento, como la normalización de texto y tokenización, deben optimizarse para el caso de uso específico. La evaluación del modelo debe incluir métricas integrales más allá de la precisión, como la precisión, recuperación y puntuación F1, particularmente para conjuntos de datos desequilibrados. El monitoreo y las actualizaciones regulares son esenciales para mantener el rendimiento a lo largo del tiempo.

Compra este libro