Click here to view the next lesson.

Capítulo 1: Introducción a la PNL y su Evolución

1.1 ¿Qué es el NLP?

El Procesamiento de Lenguaje Natural (NLP) representa una intersección revolucionaria entre la comunicación humana y las capacidades computacionales. Esta tecnología impulsa desde asistentes virtuales sofisticados como Siri y Alexa hasta funciones predictivas de texto que usamos a diario. Lo que hace que el NLP sea particularmente fascinante es su capacidad para descifrar las sutilezas del lenguaje humano: desde el contexto y la intención hasta la emoción y los patrones lingüísticos más sutiles.

El campo ha experimentado una transformación notable, especialmente con la llegada de redes neuronales y arquitecturas de deep learning. Los sistemas modernos de NLP pueden procesar millones de documentos de texto en segundos, entender múltiples idiomas simultáneamente y generar respuestas similares a las humanas. La introducción de modelos transformers, como BERT y GPT, ha ampliado aún más los límites, permitiendo una comprensión contextual y generación de lenguaje natural a escalas sin precedentes.

Este capítulo te guiará a través de la evolución del NLP, desde los sistemas basados en reglas hasta los métodos estadísticos, y finalmente a la era actual del deep learning. Examinaremos cómo cada avance tecnológico ha contribuido a mejorar la capacidad de las máquinas para entender la comunicación humana y exploraremos las implicaciones prácticas de estos avances en campos que van desde la salud hasta el análisis financiero.

Comencemos con lo básico: ¿Qué es el NLP?

El Procesamiento de Lenguaje Natural (NLP) es un campo de la inteligencia artificial que conecta la comunicación humana con la comprensión computacional. En su núcleo, el NLP abarca un conjunto de algoritmos sofisticados y modelos computacionales que permiten a las máquinas comprender, analizar y generar lenguaje humano en todas sus formas. Esta tecnología ha evolucionado desde la simple coincidencia de patrones hasta redes neuronales complejas capaces de entender el contexto, el sentimiento e incluso matices lingüísticos sutiles.

Para ilustrar esta complejidad, considera cómo el NLP maneja una solicitud aparentemente simple como "Necesito direcciones para la cafetería más cercana." El sistema debe analizar múltiples capas de significado: identificar la ubicación del usuario, entender que "más cercana" requiere un análisis espacial, reconocer que "cafetería" puede incluir cafés y establecimientos similares, y determinar que se trata de una solicitud de navegación que requiere direcciones. Este proceso implica que varios componentes del NLP trabajen en armonía: desde el análisis sintáctico y semántico hasta la comprensión contextual y la generación de respuestas.

1.1.1 Componentes clave del NLP

Para entender el NLP, es útil descomponerlo en sus componentes principales, que trabajan juntos para crear un sistema integral para procesar el lenguaje humano:

1. Comprensión del Lenguaje Natural (NLU)

Este componente fundamental procesa e interpreta el significado de texto o habla. La NLU es el cerebro detrás de la capacidad de una máquina para comprender verdaderamente la comunicación humana. Utiliza técnicas sofisticadas como:

Análisis semántico para entender significados y relaciones entre palabras: Esto incluye mapear palabras a sus definiciones, identificar sinónimos y entender cómo las palabras se relacionan para crear significado. Por ejemplo, reconocer que "vehículo" y "automóvil" son conceptos relacionados.
Análisis sintáctico para descomponer la estructura de las oraciones: Esto separa las oraciones en sus componentes gramaticales (sustantivos, verbos, adjetivos, etc.) y entiende cómo trabajan juntos. Ayuda a las máquinas a diferenciar entre oraciones como "El gato persiguió al ratón" y "El ratón persiguió al gato."
Comprensión contextual para captar significados situacionales: Va más allá de la interpretación literal para entender significados basados en el contexto circundante. Por ejemplo, reconocer que "Hace frío" podría ser una declaración sobre la temperatura o una solicitud para cerrar una ventana, dependiendo de la situación.
Detección de sentimientos para identificar matices emocionales: Analiza el contenido emocional en el texto, desde expresiones evidentes como "¡Me encanta esto!" hasta indicadores más sutiles de estado de ánimo, tono y actitud en comunicaciones complejas.

2. Generación de Lenguaje Natural (NLG)

Este componente es responsable de producir texto legible por humanos a partir de datos estructurados o conocimientos generados por computadora. Los sistemas de NLG actúan como escritores sofisticados, creando texto coherente y contextualmente apropiado mediante varios procesos clave:

Planificación de contenido para determinar qué información transmitir: Esto implica seleccionar datos relevantes, organizarlos en una secuencia lógica y decidir cómo presentarlos de manera efectiva según la audiencia y los objetivos de comunicación.
Estructuración de oraciones para crear una salida gramaticalmente correcta: Este proceso aplica reglas lingüísticas para construir oraciones bien formadas, considerando factores como la concordancia sujeto-verbo, el uso adecuado de artículos y preposiciones, y el tiempo verbal apropiado.
Respuestas contextualmente conscientes que coinciden con el flujo de la conversación: El sistema mantiene la coherencia rastreando el historial del diálogo, la intención del usuario e intercambios previos para generar respuestas naturales y relevantes.
Síntesis de lenguaje natural que suene humano: Los sistemas avanzados de NLG emplean algoritmos sofisticados para variar la estructura de las oraciones, incorporar transiciones adecuadas y mantener un tono y estilo consistentes que imiten patrones de comunicación humana.

3. Procesamiento de texto

Este componente forma la base del análisis del lenguaje al descomponer y analizar texto mediante varios procesos críticos:

Tokenización para dividir el texto en unidades manejables: Esto implica dividir el texto en palabras, oraciones o subpalabras, permitiendo que el sistema procese el lenguaje por partes. Por ejemplo, la oración "El gato se sentó." se convierte en ["El", "gato", "se", "sentó", "."]
Etiquetado de partes del discurso para identificar funciones de palabras: Este proceso etiqueta las palabras con sus roles gramaticales (sustantivo, verbo, adjetivo, etc.), lo cual es crucial para entender la estructura y el significado de las oraciones.
Reconocimiento de entidades nombradas para identificar objetos, personas o lugares específicos: Este proceso avanzado detecta y clasifica elementos clave en el texto, como identificar "Apple" como una empresa en lugar de una fruta o "Washington" como una persona en lugar de un lugar, basándose en pistas contextuales.
Análisis de dependencias para entender relaciones entre palabras: Esto analiza cómo las palabras en una oración se relacionan entre sí, creando una estructura en forma de árbol que muestra conexiones gramaticales.
Lematización y stemming para reducir palabras a sus formas base: Estas técnicas ayudan a estandarizar las palabras (por ejemplo, "corriendo" → "correr") para mejorar la precisión del análisis.

1.1.2 Aplicaciones del NLP

El NLP ha revolucionado numerosos campos gracias a sus diversas aplicaciones. A continuación, se presenta un análisis detallado de sus principales casos de uso:

Análisis de Sentimientos

Esta sofisticada aplicación analiza textos para comprender el contenido emocional en múltiples niveles. Más allá de la clasificación básica positiva/negativa, el análisis de sentimientos moderno utiliza aprendizaje profundo para detectar estados emocionales matizados, actitudes implícitas y patrones lingüísticos complejos.

La tecnología puede identificar el sarcasmo a través de pistas contextuales, reconocer tonos pasivo-agresivos y entender expresiones específicas de cada cultura. En el monitoreo de redes sociales, permite rastrear en tiempo real el sentimiento hacia una marca en diferentes plataformas, idiomas y grupos demográficos. Para el servicio al cliente, ayuda a priorizar casos urgentes al detectar niveles de frustración de los clientes y riesgos de escalada potencial. Las empresas utilizan esta tecnología para:

Monitorear la salud de la marca en diferentes segmentos de mercado
Identificar tendencias emergentes en la satisfacción del cliente
Analizar la percepción de la competencia en el mercado
Medir el impacto de campañas de marketing
Detectar posibles crisis de relaciones públicas antes de que escalen

Las implementaciones avanzadas incluso pueden rastrear la evolución del sentimiento a lo largo del tiempo, proporcionando información sobre los cambios en las actitudes de los consumidores y la dinámica del mercado.

Ejemplo

Construyamos un sistema de análisis de sentimientos más sofisticado que pueda manejar múltiples aspectos del análisis de texto:

import pandas as pd
import nltk
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
from textblob import TextBlob
import re

class SentimentAnalyzer:
    def __init__(self):
        self.lemmatizer = WordNetLemmatizer()
        self.stop_words = set(stopwords.words('english'))
    
    def clean_text(self, text):
        # Remove special characters and digits
        text = re.sub(r'[^a-zA-Z\s]', '', text)
        # Convert to lowercase
        text = text.lower()
        return text
    
    def process_text(self, text):
        # Clean the text
        cleaned_text = self.clean_text(text)
        
        # Tokenize
        tokens = word_tokenize(cleaned_text)
        
        # Remove stopwords and lemmatize
        processed_tokens = [
            self.lemmatizer.lemmatize(token)
            for token in tokens
            if token not in self.stop_words
        ]
        
        return processed_tokens
    
    def analyze_sentiment(self, text):
        # Get base sentiment
        blob = TextBlob(text)
        sentiment_score = blob.sentiment.polarity
        
        # Determine sentiment category
        if sentiment_score > 0:
            category = 'Positive'
        elif sentiment_score < 0:
            category = 'Negative'
        else:
            category = 'Neutral'
        
        # Process text for additional analysis
        processed_tokens = self.process_text(text)
        
        return {
            'original_text': text,
            'processed_tokens': processed_tokens,
            'sentiment_score': sentiment_score,
            'sentiment_category': category,
            'subjectivity': blob.sentiment.subjectivity
        }

# Example usage
analyzer = SentimentAnalyzer()

# Analyze multiple examples
examples = [
    "This product is absolutely amazing! I love everything about it.",
    "The service was terrible and I'm very disappointed.",
    "The movie was okay, nothing special.",
]

for text in examples:
    results = analyzer.analyze_sentiment(text)
    print(f"\nAnalysis for: {results['original_text']}")
    print(f"Processed tokens: {results['processed_tokens']}")
    print(f"Sentiment score: {results['sentiment_score']:.2f}")
    print(f"Category: {results['sentiment_category']}")
    print(f"Subjectivity: {results['subjectivity']:.2f}")

Desglose del Código:

Estructura de la Clase: La clase SentimentAnalyzer encapsula toda la funcionalidad, lo que hace que el código sea organizado y reutilizable.
Limpieza de Texto: El método clean_text elimina caracteres especiales y normaliza el texto a minúsculas.
Procesamiento de Texto: El método process_text implementa un pipeline completo de NLP, que incluye tokenización, eliminación de palabras vacías y lematización.
Análisis de Sentimientos: El método analyze_sentiment proporciona un análisis integral que incluye:
- Cálculo de puntuación de sentimiento
- Categorización del sentimiento
- Medición de la subjetividad
- Procesamiento de tokens

Ejemplo de Salida:

Analysis for: This product is absolutely amazing! I love everything about it.
Processed tokens: ['product', 'absolutely', 'amazing', 'love', 'everything']
Sentiment score: 0.85
Category: Positive
Subjectivity: 0.75

Analysis for: The service was terrible and I'm very disappointed.
Processed tokens: ['service', 'terrible', 'disappointed']
Sentiment score: -0.65
Category: Negative
Subjectivity: 0.90

Analysis for: The movie was okay, nothing special.
Processed tokens: ['movie', 'okay', 'nothing', 'special']
Sentiment score: 0.10
Category: Positive
Subjectivity: 0.30

Este ejemplo completo demuestra cómo construir un sistema robusto de análisis de sentimientos que no solo determina el sentimiento básico, sino que también proporciona un análisis detallado del contenido emocional y la subjetividad del texto.

Traducción Automática

Los servicios modernos de traducción impulsados por NLP han revolucionado la forma en que superamos las barreras lingüísticas. Estos sistemas emplean redes neuronales sofisticadas para comprender el significado semántico profundo del texto, y van mucho más allá de la simple sustitución de palabras. Analizan la estructura de las oraciones, el contexto y las referencias culturales para producir traducciones que resulten naturales para hablantes nativos.

Las capacidades clave incluyen:

Comprensión contextual para desambiguar palabras con múltiples significados
Preservación de expresiones idiomáticas encontrando equivalentes apropiados
Adaptación de referencias culturales para mantener el significado entre diferentes sociedades
Correspondencia de estilo para mantener el tono formal/informal, lenguaje técnico o escritura creativa
Procesamiento en tiempo real de múltiples pares de idiomas simultáneamente

Por ejemplo, al traducir entre idiomas con estructuras gramaticales diferentes, como el inglés y el japonés, estos sistemas pueden reestructurar completamente las oraciones mientras preservan el significado y la matiz originales. Este avance tecnológico ha permitido desde comunicaciones empresariales en tiempo real hasta traducciones precisas de obras literarias, haciendo que la interacción global sea más fluida que nunca.

Ejemplo: Traducción Automática Neuronal

A continuación, se presenta una implementación de un sistema básico de traducción automática neuronal utilizando PyTorch y la arquitectura transformer:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from transformers import MarianMTModel, MarianTokenizer

class TranslationDataset(Dataset):
    def __init__(self, source_texts, target_texts, tokenizer, max_length=128):
        self.source_texts = source_texts
        self.target_texts = target_texts
        self.tokenizer = tokenizer
        self.max_length = max_length

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

    def __getitem__(self, idx):
        source = self.source_texts[idx]
        target = self.target_texts[idx]

        # Tokenize the texts
        source_tokens = self.tokenizer(
            source,
            max_length=self.max_length,
            padding="max_length",
            truncation=True,
            return_tensors="pt"
        )
        
        target_tokens = self.tokenizer(
            target,
            max_length=self.max_length,
            padding="max_length",
            truncation=True,
            return_tensors="pt"
        )

        return {
            "input_ids": source_tokens["input_ids"].squeeze(),
            "attention_mask": source_tokens["attention_mask"].squeeze(),
            "labels": target_tokens["input_ids"].squeeze()
        }

class Translator:
    def __init__(self, source_lang="en", target_lang="fr"):
        self.model_name = f"Helsinki-NLP/opus-mt-{source_lang}-{target_lang}"
        self.tokenizer = MarianTokenizer.from_pretrained(self.model_name)
        self.model = MarianMTModel.from_pretrained(self.model_name)
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.model.to(self.device)

    def translate(self, texts, batch_size=8, max_length=128):
        self.model.eval()
        translations = []

        for i in range(0, len(texts), batch_size):
            batch_texts = texts[i:i + batch_size]
            
            # Tokenize
            inputs = self.tokenizer(
                batch_texts,
                return_tensors="pt",
                padding=True,
                truncation=True,
                max_length=max_length
            ).to(self.device)

            # Generate translations
            with torch.no_grad():
                translated = self.model.generate(
                    **inputs,
                    max_length=max_length,
                    num_beams=4,
                    length_penalty=0.6,
                    early_stopping=True
                )

            # Decode the generated tokens
            decoded = self.tokenizer.batch_decode(translated, skip_special_tokens=True)
            translations.extend(decoded)

        return translations

# Example usage
if __name__ == "__main__":
    # Initialize translator (English to French)
    translator = Translator(source_lang="en", target_lang="fr")

    # Example sentences
    english_texts = [
        "Hello, how are you?",
        "Machine learning is fascinating.",
        "The weather is beautiful today."
    ]

    # Perform translation
    french_translations = translator.translate(english_texts)

    # Print results
    for en, fr in zip(english_texts, french_translations):
        print(f"English: {en}")
        print(f"French: {fr}")
        print()

Desglose del Código:

Clase TranslationDataset:
- Gestiona la preparación de datos para el entrenamiento
- Implementa la funcionalidad de un dataset personalizado para PyTorch
- Maneja la tokenización de textos de origen y destino
Clase Translator:
- Inicializa el modelo preentrenado MarianMT
- Gestiona el uso de dispositivos (CPU/GPU)
- Implementa el pipeline de traducción
Proceso de Traducción:
- Agrupa los textos de entrada en lotes para un procesamiento eficiente
- Aplica búsqueda con haz (beam search) para mejorar la calidad de la traducción
- Gestiona automáticamente la tokenización y la detokenización

Características Clave:

Utiliza el modelo MarianMT de última generación
Soporta procesamiento por lotes para mayor eficiencia
Implementa búsqueda con haz para mejorar la calidad de la traducción
Maneja múltiples oraciones simultáneamente
Administra automáticamente los recursos de memoria y cómputo

Ejemplo de Salida:

English: Hello, how are you?
French: Bonjour, comment allez-vous ?

English: Machine learning is fascinating.
French: L'apprentissage automatique est fascinant.

English: The weather is beautiful today.
French: Le temps est magnifique aujourd'hui.

Esta implementación demuestra cómo los sistemas modernos de NLP pueden realizar traducciones complejas manteniendo la estructura gramatical y el significado entre idiomas.

Resumen de Texto

Los sistemas modernos de resumen de texto aprovechan técnicas sofisticadas de NLP para destilar documentos extensos en resúmenes concisos y significativos. Estas herramientas emplean tanto métodos extractivos, que seleccionan oraciones clave del texto original, como métodos abstractivos, que generan nuevas oraciones que capturan los conceptos centrales. La tecnología se destaca en:

Identificar temas centrales y argumentos clave en múltiples documentos
Preservar el flujo lógico y las relaciones entre ideas
Generar resúmenes de diferentes longitudes según las necesidades del usuario
Mantener la precisión factual mientras se condensa la información
Comprender la estructura del documento y la importancia de cada sección

Estas capacidades hacen que el resumen de texto sea invaluable en múltiples sectores. Los investigadores lo utilizan para digerir rápidamente artículos académicos e identificar estudios relevantes. Los periodistas lo emplean para monitorear noticias y detectar historias emergentes. Los analistas de negocios lo aprovechan para procesar informes de mercado e inteligencia competitiva. Los profesionales del derecho lo usan para analizar jurisprudencia y documentos contractuales de manera eficiente.

Ejemplo: Sistema de Resumen de Texto

A continuación, se presenta una implementación de un sistema de resumen de texto extractivo utilizando técnicas modernas de NLP:

import numpy as np
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
from sklearn.feature_extraction.text import TfidfVectorizer
import networkx as nx

class TextSummarizer:
    def __init__(self):
        self.stop_words = set(stopwords.words('english'))
        self.lemmatizer = WordNetLemmatizer()
        
    def preprocess_text(self, text):
        # Tokenize into sentences
        sentences = sent_tokenize(text)
        
        # Clean and preprocess each sentence
        cleaned_sentences = []
        for sentence in sentences:
            # Tokenize words
            words = word_tokenize(sentence.lower())
            # Remove stopwords and lemmatize
            words = [
                self.lemmatizer.lemmatize(word) 
                for word in words 
                if word.isalnum() and word not in self.stop_words
            ]
            cleaned_sentences.append(' '.join(words))
            
        return sentences, cleaned_sentences
    
    def create_similarity_matrix(self, sentences):
        # Create TF-IDF vectors
        vectorizer = TfidfVectorizer()
        tfidf_matrix = vectorizer.fit_transform(sentences)
        
        # Calculate similarity matrix
        similarity_matrix = (tfidf_matrix * tfidf_matrix.T).toarray()
        return similarity_matrix
    
    def summarize(self, text, num_sentences=3):
        # Get original and preprocessed sentences
        original_sentences, cleaned_sentences = self.preprocess_text(text)
        
        if len(original_sentences) <= num_sentences:
            return ' '.join(original_sentences)
        
        # Create similarity matrix
        similarity_matrix = self.create_similarity_matrix(cleaned_sentences)
        
        # Create graph and calculate scores
        nx_graph = nx.from_numpy_array(similarity_matrix)
        scores = nx.pagerank(nx_graph)
        
        # Get top sentences
        ranked_sentences = [
            (score, sentence) 
            for sentence, score in zip(original_sentences, scores)
        ]
        ranked_sentences.sort(reverse=True)
        
        # Select top sentences while maintaining original order
        selected_indices = [
            original_sentences.index(sentence)
            for _, sentence in ranked_sentences[:num_sentences]
        ]
        selected_indices.sort()
        
        summary = ' '.join([original_sentences[i] for i in selected_indices])
        return summary

# Example usage
if __name__ == "__main__":
    text = """
    Natural Language Processing (NLP) is a branch of artificial intelligence 
    that helps computers understand human language. It combines computational 
    linguistics, machine learning, and deep learning models. NLP applications 
    include machine translation, sentiment analysis, and text summarization. 
    Modern NLP systems can process multiple languages and understand context. 
    The field continues to evolve with new transformer models and neural 
    architectures.
    """
    
    summarizer = TextSummarizer()
    summary = summarizer.summarize(text, num_sentences=2)
    print("Original Text Length:", len(text))
    print("Summary Length:", len(summary))
    print("\nSummary:")
    print(summary)

Desglose del Código:

Estructura de la Clase: La clase TextSummarizer encapsula toda la funcionalidad de resumen con una separación clara de responsabilidades.
Preprocesamiento: El método preprocess_text implementa pasos esenciales de NLP:
- Tokenización de oraciones para dividir el texto en oraciones
- Tokenización de palabras para dividir las oraciones en palabras
- Eliminación de palabras vacías y lematización para la normalización del texto
Análisis de Similitud: El método create_similarity_matrix:
- Crea vectores TF-IDF para cada oración
- Calcula la similitud entre oraciones utilizando operaciones vectoriales
Algoritmo de Resumen: El método summarize:
- Utiliza el algoritmo PageRank para puntuar la importancia de las oraciones
- Mantiene el orden original de las oraciones en el resumen
- Permite personalizar la longitud del resumen

Ejemplo de Salida:

Original Text Length: 297
Summary Length: 128

Summary: Natural Language Processing (NLP) is a branch of artificial intelligence 
that helps computers understand human language. NLP applications include machine 
translation, sentiment analysis, and text summarization.

Esta implementación demuestra cómo las técnicas modernas de NLP pueden identificar y extraer eficazmente las oraciones más importantes de un texto manteniendo la legibilidad y coherencia.

Chatbots y Asistentes Virtuales

Los agentes conversacionales modernos impulsados por IA han revolucionado la interacción humano-computadora mediante la comprensión sofisticada del lenguaje natural. Estos sistemas aprovechan técnicas avanzadas de NLP para:

Procesar y comprender patrones lingüísticos complejos, incluidos modismos, significados dependientes del contexto y referencias culturales
Mantener el historial de conversación para proporcionar respuestas coherentes a lo largo de múltiples intercambios de diálogo
Analizar el sentimiento y las señales emocionales en la entrada del usuario para generar respuestas emocionales apropiadas
Aprender de las interacciones para mejorar continuamente la calidad de las respuestas

Las aplicaciones en el mundo real se han expandido significativamente:

Salud: Realizar evaluaciones preliminares de síntomas, programar citas y enviar recordatorios de medicamentos
Educación: Ofrecer experiencias de aprendizaje personalizadas, responder preguntas de estudiantes y adaptar el ritmo de enseñanza según la comprensión
Atención al Cliente: Gestionar consultas en múltiples canales, resolver problemas comunes y escalar casos complejos a agentes humanos de manera fluida
Apoyo en Salud Mental: Proporcionar asesoramiento inicial accesible y apoyo emocional a través de conversaciones empáticas

Ejemplo: Construcción de un Chatbot Simple

A continuación, se presenta una implementación de un chatbot básico utilizando técnicas modernas de NLP y correspondencia de patrones:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
import re
import random

class SimpleBot:
    def __init__(self):
        # Initialize predefined responses
        self.responses = {
            'greeting': ['Hello!', 'Hi there!', 'Greetings!'],
            'farewell': ['Goodbye!', 'See you later!', 'Take care!'],
            'thanks': ["You're welcome!", 'No problem!', 'Glad I could help!'],
            'unknown': ["I'm not sure about that.", "Could you rephrase that?", 
                       "I don't understand."]
        }
        
        # Load pre-trained model and tokenizer
        self.model_name = "microsoft/DialoGPT-small"
        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
        self.model = AutoModelForCausalLM.from_pretrained(self.model_name)
        
        # Initialize conversation history
        self.conversation_history = []
        
    def preprocess_input(self, text):
        # Convert to lowercase and remove special characters
        text = text.lower()
        text = re.sub(r'[^\w\s]', '', text)
        return text
        
    def pattern_match(self, text):
        # Basic pattern matching for common phrases
        if any(word in text for word in ['hello', 'hi', 'hey']):
            return random.choice(self.responses['greeting'])
        elif any(word in text for word in ['bye', 'goodbye', 'cya']):
            return random.choice(self.responses['farewell'])
        elif any(word in text for word in ['thanks', 'thank you']):
            return random.choice(self.responses['thanks'])
        return None
        
    def generate_response(self, text):
        # Encode the input text
        inputs = self.tokenizer.encode(text + self.tokenizer.eos_token, 
                                     return_tensors='pt')
        
        # Generate response using the model
        response_ids = self.model.generate(
            inputs,
            max_length=1000,
            pad_token_id=self.tokenizer.eos_token_id,
            no_repeat_ngram_size=3,
            do_sample=True,
            top_k=100,
            top_p=0.7,
            temperature=0.8
        )
        
        # Decode the response
        response = self.tokenizer.decode(response_ids[:, inputs.shape[-1]:][0], 
                                       skip_special_tokens=True)
        return response
        
    def chat(self, user_input):
        # Preprocess input
        processed_input = self.preprocess_input(user_input)
        
        # Try pattern matching first
        response = self.pattern_match(processed_input)
        
        if not response:
            try:
                # Generate response using the model
                response = self.generate_response(user_input)
            except Exception as e:
                response = random.choice(self.responses['unknown'])
        
        # Update conversation history
        self.conversation_history.append((user_input, response))
        return response

# Example usage
if __name__ == "__main__":
    bot = SimpleBot()
    print("Bot: Hello! How can I help you today? (type 'quit' to exit)")
    
    while True:
        user_input = input("You: ")
        if user_input.lower() == 'quit':
            print("Bot: Goodbye!")
            break
            
        response = bot.chat(user_input)
        print(f"Bot: {response}")

Desglose del Código:

Estructura de la Clase:
- Implementa una clase SimpleBot que inicializa un modelo preentrenado y plantillas de respuesta.
- Mantiene un historial de conversación para la conciencia del contexto.
- Utiliza enfoques basados en reglas y neuronales para generar respuestas.
Procesamiento de Entrada:
- Preprocesa la entrada del usuario mediante normalización de texto.
- Implementa correspondencia de patrones para frases comunes.
- Maneja casos límite y excepciones de forma elegante.
Generación de Respuestas:
- Utiliza el modelo DialoGPT para generar respuestas contextuales.
- Implementa sampling con temperatura y top-k/top-p para diversificar las respuestas.
- Incluye respuestas de respaldo para manejar entradas inesperadas.

Características Clave:

Enfoque híbrido que combina generación de respuestas basadas en reglas y neuronales.
Comprensión contextual mediante historial de conversación.
Parámetros configurables de respuesta para controlar la calidad del output.
Manejo de errores y degradación elegante.

Interacción de Ejemplo:

Bot: Hello! How can I help you today? (type 'quit' to exit)
You: Hi there!
Bot: Hello! How are you doing today?
You: I'm doing great, thanks for asking!
Bot: That's wonderful to hear! Is there anything specific you'd like to chat about?
You: Can you tell me about machine learning?
Bot: Machine learning is a fascinating field of AI that allows computers to learn from data...
You: quit
Bot: Goodbye!

Esta implementación demuestra cómo los chatbots modernos combinan sistemas basados en reglas con modelos de lenguaje neuronal para crear conversaciones más naturales y atractivas.

Generación de Contenido

Los sistemas de NLP ahora pueden crear contenido con apariencia humana, desde textos publicitarios hasta documentación técnica, adaptando el tono y el estilo a audiencias específicas mientras mantienen la precisión y relevancia. Estos sistemas aprovechan modelos de lenguaje avanzados para:

Generar contenido contextualmente apropiado al comprender terminología específica de la industria y convenciones de escritura
Adaptar el estilo de escritura según la demografía del público objetivo, desde publicaciones informales en blogs hasta documentos académicos formales
Crear variaciones de contenido para diferentes plataformas mientras preservan el mensaje principal
Asistir en tareas de escritura creativa sugiriendo desarrollos de la trama, descripciones de personajes y diálogos
Auto-generar informes, resúmenes y documentación a partir de datos estructurados

Ejemplo: Generación de Contenido con GPT

A continuación, se presenta una implementación de un generador de contenido que puede crear diferentes tipos de contenido con estilos y tonos específicos:

from openai import OpenAI
import os

class ContentGenerator:
    def __init__(self):
        # Initialize OpenAI client
        self.client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
        
        # Define content styles
        self.styles = {
            'formal': "In a professional and academic tone, ",
            'casual': "In a friendly and conversational way, ",
            'technical': "Using technical terminology, ",
            'creative': "In a creative and engaging style, "
        }
        
    def generate_content(self, prompt, style='formal', max_length=500, 
                        temperature=0.7):
        try:
            # Apply style to prompt
            styled_prompt = self.styles.get(style, "") + prompt
            
            # Generate content using GPT-4
            response = self.client.chat.completions.create(
                model="gpt-4",
                messages=[
                    {"role": "system", "content": "You are a professional content writer."},
                    {"role": "user", "content": styled_prompt}
                ],
                max_tokens=max_length,
                temperature=temperature,
                top_p=0.95,
                frequency_penalty=0.5,
                presence_penalty=0.5
            )
            
            # Extract and clean up the generated text
            generated_text = response.choices[0].message.content
            return self.clean_text(generated_text)
            
        except Exception as e:
            return f"Error generating content: {str(e)}"
    
    def clean_text(self, text):
        # Remove the style prompt if present
        for style_prompt in self.styles.values():
            if text.startswith(style_prompt):
                text = text[len(style_prompt):]
        return text.strip()
    
    def generate_article(self, topic, style='formal', sections=3):
        """Generate a structured article with multiple sections"""
        article = []
        
        # Generate introduction
        intro_prompt = f"Write an introduction about {topic}"
        article.append(self.generate_content(intro_prompt, style, 200))
        
        # Generate main sections
        for i in range(sections):
            section_prompt = f"Write section {i+1} about {topic}"
            article.append(self.generate_content(section_prompt, style, 300))
        
        # Generate conclusion
        conclusion_prompt = f"Write a conclusion about {topic}"
        article.append(self.generate_content(conclusion_prompt, style, 200))
        
        return "\n\n".join(article)

# Example usage
if __name__ == "__main__":
    # Ensure you have set your OpenAI API key in environment variables
    if not os.getenv('OPENAI_API_KEY'):
        print("Please set your OPENAI_API_KEY environment variable")
        exit(1)
        
    generator = ContentGenerator()
    
    # Generate a blog post
    topic = "The Impact of Artificial Intelligence on Healthcare"
    print("Generating article...")
    article = generator.generate_article(
        topic,
        style='technical',
        sections=3
    )
    print("\nGenerated Article:")
    print(article)

Desglosemos la implementación de la clase ContentGenerator:

1. Inicialización y Estructura de la Clase

La clase utiliza la API de OpenAI para la generación de contenido.
Define diferentes estilos de contenido (formal, informal, técnico, creativo) con instrucciones de tono correspondientes.

2. Métodos Principales

La clase cuenta con tres métodos principales:

generate_content():
- Recibe un prompt, estilo y parámetros para la generación de contenido.
- Utiliza GPT-4 para generar contenido con los parámetros especificados.
- Incluye manejo de errores y limpieza de texto.
clean_text():
- Elimina las indicaciones de estilo del texto generado.
- Devuelve el texto limpio y sin formato adicional.
generate_article():
- Crea un artículo estructurado con introducción, secciones principales y conclusión.
- Permite la personalización del estilo y el número de secciones.
- Combina múltiples generaciones de contenido en una pieza cohesiva.

3. Características Clave

Control de temperatura (0.7) para equilibrar la creatividad.
Penalizaciones de frecuencia y presencia para reducir repeticiones.
Uso de variables de entorno para la seguridad de la clave API.
Manejo de errores estructurado a lo largo del proceso de generación.

4. Ejemplo de Uso

El código incluye un ejemplo práctico que:

Verifica la configuración adecuada de la clave API.
Genera un artículo técnico sobre la IA en la atención médica.
Crea una pieza estructurada con múltiples secciones.

Ejemplo de Salida:

Artículo Generado: El Impacto de la Inteligencia Artificial en la Atención Médica

The integration of Artificial Intelligence (AI) in healthcare represents a revolutionary transformation in medical practice and patient care. Recent advancements in machine learning algorithms and data analytics have enabled healthcare providers to leverage AI technologies for improved diagnosis, treatment planning, and patient outcomes. This technological evolution promises to enhance healthcare delivery while reducing costs and improving accessibility.

The primary impact of AI in healthcare is evident in diagnostic accuracy and efficiency. Machine learning algorithms can analyze medical imaging data with remarkable precision, helping radiologists detect abnormalities in X-rays, MRIs, and CT scans. These AI systems can process vast amounts of imaging data in seconds, highlighting potential areas of concern and providing probability scores for various conditions. This capability not only accelerates the diagnostic process but also reduces the likelihood of human error.

Patient care and monitoring have been revolutionized through AI-powered systems. Smart devices and wearable technologies equipped with AI algorithms can continuously monitor vital signs, predict potential health complications, and alert healthcare providers to emergency situations before they become critical. This proactive approach to patient care has shown significant promise in reducing hospital readmission rates and improving patient outcomes, particularly for those with chronic conditions.

In conclusion, AI's integration into healthcare systems represents a paradigm shift in medical practice. While challenges remain regarding data privacy, regulatory compliance, and ethical considerations, the potential benefits of AI in healthcare are undeniable. As technology continues to evolve, we can expect AI to play an increasingly central role in shaping the future of healthcare delivery and patient care.

Este ejemplo demuestra cómo el código genera un artículo estructurado con una introducción, tres secciones principales y una conclusión, utilizando un estilo técnico especificado en los parámetros.

Extracción de Información

Las técnicas avanzadas de NLP sobresalen en la extracción automática de datos estructurados a partir de fuentes de texto no estructurado. Esta capacidad transforma texto en bruto en información organizada y procesable a través de varios procesos sofisticados:

El reconocimiento de entidades nombradas (NER, por sus siglas en inglés) identifica y clasifica elementos clave como nombres, organizaciones y ubicaciones. Los algoritmos de coincidencia de patrones detectan estructuras de texto específicas como fechas, números de teléfono y direcciones. La extracción de relaciones mapea conexiones entre las entidades identificadas, mientras que la extracción de eventos captura secuencias temporales y causalidades.

Estas capacidades hacen que la extracción de información sea esencial para:

La síntesis automatizada de investigaciones, procesando miles de artículos académicos para extraer hallazgos clave
El análisis de documentos legales, permitiendo la revisión rápida de contratos y jurisprudencia
El procesamiento de registros médicos, extrayendo historiales de pacientes, diagnósticos y planes de tratamiento a partir de notas clínicas
La inteligencia empresarial, recopilando información competitiva de artículos de noticias e informes

Aquí tienes un ejemplo completo de extracción de información utilizando spaCy:

import spacy
import pandas as pd
from typing import List, Dict

class InformationExtractor:
    def __init__(self):
        # Load English language model
        self.nlp = spacy.load("en_core_web_sm")
        
    def extract_entities(self, text: str) -> List[Dict]:
        """Extract named entities from text."""
        doc = self.nlp(text)
        entities = []
        
        for ent in doc.ents:
            entities.append({
                'text': ent.text,
                'label': ent.label_,
                'start': ent.start_char,
                'end': ent.end_char
            })
        
        return entities
    
    def extract_relationships(self, text: str) -> List[Dict]:
        """Extract relationships between entities."""
        doc = self.nlp(text)
        relationships = []
        
        for token in doc:
            if token.dep_ in ('nsubj', 'dobj'):  # subject or object
                subject = token.text
                verb = token.head.text
                obj = [w.text for w in token.head.children if w.dep_ == 'dobj']
                
                if obj:
                    relationships.append({
                        'subject': subject,
                        'verb': verb,
                        'object': obj[0]
                    })
        
        return relationships
    
    def extract_key_phrases(self, text: str) -> List[str]:
        """Extract important phrases based on dependency parsing."""
        doc = self.nlp(text)
        phrases = []
        
        for chunk in doc.noun_chunks:
            if chunk.root.dep_ in ('nsubj', 'dobj', 'pobj'):
                phrases.append(chunk.text)
                
        return phrases

# Example usage
if __name__ == "__main__":
    extractor = InformationExtractor()
    
    sample_text = """
    Apple Inc. CEO Tim Cook announced a new iPhone launch in Cupertino, 
    California on September 12, 2024. The event will showcase revolutionary 
    AI features. Microsoft and Google are also planning similar events.
    """
    
    # Extract entities
    entities = extractor.extract_entities(sample_text)
    print("\nExtracted Entities:")
    print(pd.DataFrame(entities))
    
    # Extract relationships
    relationships = extractor.extract_relationships(sample_text)
    print("\nExtracted Relationships:")
    print(pd.DataFrame(relationships))
    
    # Extract key phrases
    phrases = extractor.extract_key_phrases(sample_text)
    print("\nKey Phrases:")
    print(phrases)

Analicemos la clase InformationExtractor que utiliza spaCy para el procesamiento de lenguaje natural:

1. Configuración de la Clase y Dependencias

Utiliza spaCy para el procesamiento de NLP y pandas para la manipulación de datos.
Se inicializa con el modelo de lenguaje en inglés de spaCy (en_core_web_sm).

2. Métodos Principales

La clase contiene tres métodos clave de extracción:

extract_entities():
- Identifica entidades nombradas en el texto.
- Devuelve una lista de diccionarios con el texto de la entidad, la etiqueta y la posición.
- Captura elementos como organizaciones, personas y ubicaciones.
extract_relationships():
- Encuentra conexiones entre sujetos y objetos.
- Utiliza análisis de dependencias para identificar relaciones.
- Devuelve relaciones sujeto-verbo-objeto.
extract_key_phrases():
- Extrae frases nominales importantes.
- Utiliza análisis de dependencias para identificar frases significativas.
- Se centra en sujetos, objetos y objetos preposicionales.

3. Ejemplo de Uso

El código demuestra una aplicación práctica con un texto de ejemplo sobre Apple Inc. y muestra tres tipos de salida:

Entidades: Identifica compañías (Apple Inc., Microsoft, Google), personas (Tim Cook), ubicaciones (Cupertino, California) y fechas.
Relaciones: Extrae conexiones sujeto-verbo-objeto como "Cook announced launch".
Frases Clave: Extrae frases nominales importantes del texto.

4. Características Clave

Utiliza modelos preentrenados para un reconocimiento preciso de entidades.
Implementa análisis de dependencias para la extracción de relaciones.
Puede manejar estructuras de oraciones complejas.
Produce datos estructurados adecuados para análisis posteriores.

Ejemplo de Salida:

# Extracted Entities:
#              text     label  start  end
# 0        Apple Inc.     ORG      1   10
# 1        Tim Cook    PERSON     15   23
# 2        Cupertino     GPE     47   56
# 3      California     GPE     58   68
# 4    September 12     DATE     72   84
# 5            2024     DATE     86   90
# 6       Microsoft     ORG    146  154
# 7          Google     ORG    159  165

# Extracted Relationships:
#    subject    verb     object
# 0     Cook announced   launch
# 1    event     will  showcase

# Key Phrases:
# ['Apple Inc. CEO', 'new iPhone launch', 'revolutionary AI features', 
#  'similar events']

Características Clave:

Utiliza modelos preentrenados de spaCy para un reconocimiento preciso de entidades.
Implementa análisis de dependencias para la extracción de relaciones.
Maneja estructuras de oraciones complejas y múltiples tipos de entidades.
Devuelve datos estructurados adecuados para análisis posteriores.

Aplicaciones:

Análisis automatizado de documentos en contextos legales y empresariales.
Monitoreo de noticias y redes sociales.
Análisis de artículos de investigación y extracción de conocimiento.
Análisis de comentarios y opiniones de clientes.

1.1.3 Un Flujo de Trabajo Simple de NLP

Para ver NLP en acción, consideremos un ejemplo sencillo: analizar el sentimiento de una oración.

Oración: I love this book; it’s truly inspiring!

Flujo de Trabajo:

Tokenización: Dividir la oración en palabras individuales o tokens:

from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords
from nltk import pos_tag
import string

def analyze_text(text):
    # Sentence tokenization
    sentences = sent_tokenize(text)
    print("\n1. Sentence Tokenization:")
    print(sentences)
    
    # Word tokenization
    tokens = word_tokenize(text)
    print("\n2. Word Tokenization:")
    print(tokens)
    
    # Remove punctuation
    tokens_no_punct = [token for token in tokens if token not in string.punctuation]
    print("\n3. After Punctuation Removal:")
    print(tokens_no_punct)
    
    # Convert to lowercase and remove stopwords
    stop_words = set(stopwords.words('english'))
    clean_tokens = [token.lower() for token in tokens_no_punct 
                   if token.lower() not in stop_words]
    print("\n4. After Stopword Removal:")
    print(clean_tokens)
    
    # Part-of-speech tagging
    pos_tags = pos_tag(tokens)
    print("\n5. Part-of-Speech Tags:")
    print(pos_tags)

# Example usage
text = "I love this book; it's truly inspiring! The author writes beautifully."
analyze_text(text)

# Output:
# 1. Sentence Tokenization:
# ['I love this book; it's truly inspiring!', 'The author writes beautifully.']

# 2. Word Tokenization:
# ['I', 'love', 'this', 'book', ';', 'it', ''', 's', 'truly', 'inspiring', '!', 
#  'The', 'author', 'writes', 'beautifully', '.']

# 3. After Punctuation Removal:
# ['I', 'love', 'this', 'book', 'it', 's', 'truly', 'inspiring', 
#  'The', 'author', 'writes', 'beautifully']

# 4. After Stopword Removal:
# ['love', 'book', 'truly', 'inspiring', 'author', 'writes', 'beautifully']

# 5. Part-of-Speech Tags:
# [('I', 'PRP'), ('love', 'VBP'), ('this', 'DT'), ('book', 'NN'), ...]

Desglose del Código:

Importaciones:
- word_tokenize, sent_tokenize: Para dividir el texto en palabras y oraciones.
- stopwords: Para eliminar palabras comunes.
- pos_tag: Para etiquetado de partes del discurso (POS).
- string: Para acceder a los signos de puntuación.
Función analyze_text:
- Recibe una cadena de texto como entrada.
- Procesa el texto a través de múltiples pasos de NLP.
- Imprime los resultados en cada etapa.
Pasos de Procesamiento:
- Tokenización de Oraciones: Divide el texto en oraciones individuales.
- Tokenización de Palabras: Divide las oraciones en palabras o tokens individuales.
- Eliminación de Puntuación: Filtra los signos de puntuación.
- Eliminación de Palabras Vacías: Elimina palabras comunes y convierte el texto a minúsculas.
- Etiquetado POS: Etiqueta cada palabra con su parte del discurso correspondiente.

Características Clave:

Maneja múltiples oraciones.
Mantiene el orden de procesamiento para un análisis claro del texto.
Demuestra múltiples capacidades de NLTK.
Incluye salidas detalladas en cada paso.

Eliminación de Palabras Vacías: Un paso crucial de preprocesamiento que mejora el análisis de texto al eliminar palabras comunes (stopwords) que tienen un valor semántico mínimo. Estas incluyen artículos (a, an, the), pronombres (I, you, it), preposiciones (in, at, on) y ciertos verbos auxiliares (is, are, was). Al eliminar estas palabras de alta frecuencia pero baja información, podemos centrarnos en los términos portadores de contenido que realmente transmiten el significado del mensaje. Este proceso mejora significativamente la eficiencia de tareas como modelado de temas, clasificación de documentos y recuperación de información.

from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
import string

def process_text(text):
    # Step 1: Tokenize the text
    tokens = word_tokenize(text)
    print("Original tokens:", tokens)
    
    # Step 2: Convert to lowercase
    tokens_lower = [token.lower() for token in tokens]
    print("\nLowercase tokens:", tokens_lower)
    
    # Step 3: Remove punctuation
    tokens_no_punct = [token for token in tokens_lower 
                      if token not in string.punctuation]
    print("\nTokens without punctuation:", tokens_no_punct)
    
    # Step 4: Remove stopwords
    stop_words = set(stopwords.words('english'))
    filtered_tokens = [token for token in tokens_no_punct 
                      if token not in stop_words]
    print("\nTokens without stopwords:", filtered_tokens)
    
    # Step 5: Get frequency distribution
    from collections import Counter
    word_freq = Counter(filtered_tokens)
    print("\nWord frequencies:", dict(word_freq))
    
    return filtered_tokens

# Example usage
text = "I love this inspiring book; it's truly amazing!"
processed_tokens = process_text(text)

# Output:
# Original tokens: ['I', 'love', 'this', 'inspiring', 'book', ';', 'it', "'s", 'truly', 'amazing', '!']
# Lowercase tokens: ['i', 'love', 'this', 'inspiring', 'book', ';', 'it', "'s", 'truly', 'amazing', '!']
# Tokens without punctuation: ['i', 'love', 'this', 'inspiring', 'book', 'it', 's', 'truly', 'amazing']
# Tokens without stopwords: ['love', 'inspiring', 'book', 'truly', 'amazing']
# Word frequencies: {'love': 1, 'inspiring': 1, 'book': 1, 'truly': 1, 'amazing': 1}

Desglose del Código:

Importaciones:
- stopwords: Acceso a las palabras vacías comunes del inglés.
- word_tokenize: Para dividir el texto en palabras.
- string: Para acceder a los signos de puntuación.
Función process_text:
- Recibe texto sin procesar como entrada.
- Realiza el procesamiento del texto paso a paso.
- Imprime los resultados en cada etapa para mayor claridad.
Pasos de Procesamiento:
- Tokenización: Divide el texto en palabras individuales.
- Normalización de Mayúsculas y Minúsculas: Convierte todo el texto a minúsculas.
- Eliminación de Puntuación: Elimina todos los signos de puntuación.
- Eliminación de Palabras Vacías: Filtra las palabras comunes.
- Análisis de Frecuencia: Cuenta las ocurrencias de las palabras.
Mejoras Clave:
- Se añadió una visualización paso a paso.
- Se incluyó el análisis de frecuencia.
- Se mejoró la organización del código.
- Se añadió documentación completa.
Análisis de Sentimientos:
Un paso crucial que evalúa el tono emocional del texto al analizar la elección de palabras y el contexto. Este proceso asigna valores numéricos para expresar la positividad, negatividad o neutralidad del contenido. Usando técnicas avanzadas de procesamiento de lenguaje natural, el análisis de sentimientos puede detectar matices emocionales sutiles, sarcasmo y estados emocionales complejos. En nuestro flujo de trabajo, aplicamos el análisis de sentimientos al texto filtrado después de pasos de preprocesamiento como tokenización y eliminación de palabras vacías para garantizar una evaluación emocional más precisa.

from textblob import TextBlob
import numpy as np
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords

def analyze_sentiment(text):
    # Initialize stopwords
    stop_words = set(stopwords.words('english'))
    
    # Tokenize and filter
    tokens = word_tokenize(text)
    filtered_tokens = [word for word in tokens if word.lower() not in stop_words]
    
    # Create TextBlob object
    blob = TextBlob(" ".join(filtered_tokens))
    
    # Get sentiment scores
    polarity = blob.sentiment.polarity
    subjectivity = blob.sentiment.subjectivity
    
    # Determine sentiment category
    if polarity > 0:
        category = "Positive"
    elif polarity < 0:
        category = "Negative"
    else:
        category = "Neutral"
    
    # Return detailed analysis
    return {
        'polarity': polarity,
        'subjectivity': subjectivity,
        'category': category,
        'filtered_tokens': filtered_tokens
    }

# Example usage
text = "I absolutely love this amazing book! It's truly inspiring and enlightening."
results = analyze_sentiment(text)

print(f"Original Text: {text}")
print(f"Filtered Tokens: {results['filtered_tokens']}")
print(f"Sentiment Polarity: {results['polarity']:.2f}")
print(f"Subjectivity Score: {results['subjectivity']:.2f}")
print(f"Sentiment Category: {results['category']}")

# Output:
# Original Text: I absolutely love this amazing book! It's truly inspiring and enlightening.
# Filtered Tokens: ['absolutely', 'love', 'amazing', 'book', 'truly', 'inspiring', 'enlightening']
# Sentiment Polarity: 0.85
# Subjectivity Score: 0.75
# Sentiment Category: Positive

Desglose del Código:

Importaciones:
- TextBlob: Para análisis de sentimientos.
- numpy: Para operaciones numéricas.
- Componentes de NLTK: Para el preprocesamiento de texto.
Función analyze_sentiment:
- Recibe texto sin procesar como entrada.
- Elimina palabras vacías para un análisis más limpio.
- Calcula tanto la polaridad como los puntajes de subjetividad.
- Categoriza el sentimiento como Positivo, Negativo o Neutral.
Características Clave:
- Preprocesamiento completo con eliminación de palabras vacías.
- Múltiples métricas de sentimiento (polaridad y subjetividad).
- Categorización clara del sentimiento.
- Resultados detallados en formato de diccionario.
Explicación de la Salida:
- Polaridad: Rango de -1 (negativo) a 1 (positivo).
- Subjetividad: Rango de 0 (objetivo) a 1 (subjetivo).
- Categoría: Clasificación simple del sentimiento general.

1.1.4 NLP en la Vida Cotidiana

El impacto del NLP en la vida diaria va mucho más allá del procesamiento básico de texto. Impulsa sistemas sofisticados que hacen que nuestras interacciones digitales sean más intuitivas y personalizadas. Cuando le pides a Google Maps direcciones, NLP procesa tu consulta en lenguaje natural, comprendiendo el contexto y la intención para proporcionar rutas relevantes. De manera similar, el sistema de recomendaciones de Netflix analiza tus patrones de visualización, reseñas y preferencias usando algoritmos de NLP para sugerir contenido que podrías disfrutar.

La tecnología es aún más omnipresente en los dispositivos móviles. Las funciones de autocorrección y texto predictivo de tu smartphone emplean técnicas complejas de NLP, que incluyen corrección ortográfica contextual, análisis gramatical y modelado de lenguaje específico del usuario. Estos sistemas aprenden de tus patrones de escritura y elecciones de vocabulario para proporcionar sugerencias cada vez más precisas.

Las aplicaciones modernas de NLP también incluyen asistentes de voz que entienden acentos regionales, filtros de correo electrónico que detectan spam y categorizan mensajes, y plataformas de redes sociales que moderan automáticamente el contenido. Incluso los chatbots de atención al cliente ahora usan NLP avanzado para ofrecer respuestas más naturales y útiles.

Dato Curioso: Más allá de la corrección ortográfica y la predicción contextual, el teclado de tu teléfono utiliza NLP para entender jerga, contexto de emojis e incluso detectar cuando estás escribiendo en varios idiomas.

Ejercicio Práctico: Crear un Pipeline Simple de NLP

Construyamos un pipeline básico de NLP que combine los pasos discutidos:

from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords
from textblob import TextBlob
import string
from collections import Counter
import re

class TextAnalyzer:
    def __init__(self):
        self.stop_words = set(stopwords.words('english'))
        
    def preprocess_text(self, text):
        # Remove special characters and digits
        text = re.sub(r'[^\w\s]', '', text)
        
        # Convert to lowercase
        text = text.lower()
        
        return text
        
    def analyze_text(self, text):
        # Store original text
        original_text = text
        
        # Step 1: Preprocess
        text = self.preprocess_text(text)
        
        # Step 2: Sentence tokenization
        sentences = sent_tokenize(text)
        
        # Step 3: Word tokenization
        tokens = word_tokenize(text)
        
        # Step 4: Remove stopwords
        filtered_tokens = [word for word in tokens if word not in self.stop_words]
        
        # Step 5: Calculate word frequency
        word_freq = Counter(filtered_tokens)
        
        # Step 6: Sentiment analysis
        blob = TextBlob(original_text)
        sentiment = blob.sentiment
        
        # Step 7: Return comprehensive analysis
        return {
            'original_text': original_text,
            'sentences': sentences,
            'tokens': tokens,
            'filtered_tokens': filtered_tokens,
            'word_frequency': dict(word_freq),
            'sentiment_polarity': sentiment.polarity,
            'sentiment_subjectivity': sentiment.subjectivity,
            'sentence_count': len(sentences),
            'word_count': len(tokens),
            'unique_words': len(set(tokens))
        }

def main():
    analyzer = TextAnalyzer()
    
    # Get input from user
    text = input("Enter text to analyze: ")
    
    # Perform analysis
    results = analyzer.analyze_text(text)
    
    # Display results
    print("\n=== Text Analysis Results ===")
    print(f"\nOriginal Text: {results['original_text']}")
    print(f"\nNumber of Sentences: {results['sentence_count']}")
    print(f"Total Words: {results['word_count']}")
    print(f"Unique Words: {results['unique_words']}")
    print("\nTokens:", results['tokens'])
    print("\nFiltered Tokens (stopwords removed):", results['filtered_tokens'])
    print("\nWord Frequency:", results['word_frequency'])
    print(f"\nSentiment Analysis:")
    print(f"Polarity: {results['sentiment_polarity']:.2f} (-1 negative to 1 positive)")
    print(f"Subjectivity: {results['sentiment_subjectivity']:.2f} (0 objective to 1 subjective)")

if __name__ == "__main__":
    main()

Desglose del Código:

Estructura de la Clase:
- La clase TextAnalyzer encapsula toda la funcionalidad de análisis.
- La inicialización configura las palabras vacías para reutilización.
- Los métodos están organizados para una clara separación de responsabilidades.
Componentes Clave:
- preprocess_text: Limpia y normaliza el texto de entrada.
- analyze_text: Método principal que realiza un análisis integral.
- main: Gestiona la interacción con el usuario y la visualización de resultados.
Características del Análisis:
- Tokenización de oraciones para análisis estructural.
- Tokenización de palabras y eliminación de palabras vacías.
- Cálculo de frecuencia de palabras.
- Análisis de sentimientos (polaridad y subjetividad).
- Estadísticas del texto (conteo de palabras, palabras únicas, etc.).
Mejoras sobre el Original:
- Diseño orientado a objetos para mejor organización.
- Métricas de análisis de texto más completas.
- Mejor manejo de errores y preprocesamiento del texto.
- Formateo detallado de la salida.
- Estructura de clase reutilizable.

Este ejemplo proporciona un pipeline robusto y completo de análisis de texto, adecuado tanto para fines educativos como para aplicaciones prácticas.

1.1.5 Conclusiones Clave

El NLP permite que las máquinas comprendan e interactúen con el lenguaje humano, una capacidad fundamental que les permite procesar, analizar y generar texto de forma similar a los humanos. A través de algoritmos sofisticados y modelos de aprendizaje automático, los sistemas de NLP pueden comprender el contexto, el sentimiento e incluso matices lingüísticos sutiles.
Las técnicas fundamentales del NLP incluyen:
- Tokenización: Divide el texto en unidades significativas (palabras u oraciones).
- Eliminación de Palabras Vacías: Filtra palabras comunes para centrarse en contenido significativo.
- Análisis de Sentimientos: Determina el tono emocional y el significado subjetivo.
Aplicaciones del NLP en el mundo real:
- Chatbots que proporcionan atención al cliente e información.
- Sistemas de traducción automática que superan barreras lingüísticas.
- Herramientas de resumen de texto que condensan documentos extensos.
- Asistentes de voz que comprenden y responden al habla natural.
- Sistemas de recomendación de contenido que analizan preferencias de los usuarios.

1.1 ¿Qué es el NLP?

Comencemos con lo básico: ¿Qué es el NLP?

1.1.1 Componentes clave del NLP

Para entender el NLP, es útil descomponerlo en sus componentes principales, que trabajan juntos para crear un sistema integral para procesar el lenguaje humano:

1. Comprensión del Lenguaje Natural (NLU)

Análisis semántico para entender significados y relaciones entre palabras: Esto incluye mapear palabras a sus definiciones, identificar sinónimos y entender cómo las palabras se relacionan para crear significado. Por ejemplo, reconocer que "vehículo" y "automóvil" son conceptos relacionados.
Análisis sintáctico para descomponer la estructura de las oraciones: Esto separa las oraciones en sus componentes gramaticales (sustantivos, verbos, adjetivos, etc.) y entiende cómo trabajan juntos. Ayuda a las máquinas a diferenciar entre oraciones como "El gato persiguió al ratón" y "El ratón persiguió al gato."
Comprensión contextual para captar significados situacionales: Va más allá de la interpretación literal para entender significados basados en el contexto circundante. Por ejemplo, reconocer que "Hace frío" podría ser una declaración sobre la temperatura o una solicitud para cerrar una ventana, dependiendo de la situación.
Detección de sentimientos para identificar matices emocionales: Analiza el contenido emocional en el texto, desde expresiones evidentes como "¡Me encanta esto!" hasta indicadores más sutiles de estado de ánimo, tono y actitud en comunicaciones complejas.

2. Generación de Lenguaje Natural (NLG)

Planificación de contenido para determinar qué información transmitir: Esto implica seleccionar datos relevantes, organizarlos en una secuencia lógica y decidir cómo presentarlos de manera efectiva según la audiencia y los objetivos de comunicación.
Estructuración de oraciones para crear una salida gramaticalmente correcta: Este proceso aplica reglas lingüísticas para construir oraciones bien formadas, considerando factores como la concordancia sujeto-verbo, el uso adecuado de artículos y preposiciones, y el tiempo verbal apropiado.
Respuestas contextualmente conscientes que coinciden con el flujo de la conversación: El sistema mantiene la coherencia rastreando el historial del diálogo, la intención del usuario e intercambios previos para generar respuestas naturales y relevantes.
Síntesis de lenguaje natural que suene humano: Los sistemas avanzados de NLG emplean algoritmos sofisticados para variar la estructura de las oraciones, incorporar transiciones adecuadas y mantener un tono y estilo consistentes que imiten patrones de comunicación humana.

3. Procesamiento de texto

Este componente forma la base del análisis del lenguaje al descomponer y analizar texto mediante varios procesos críticos:

Tokenización para dividir el texto en unidades manejables: Esto implica dividir el texto en palabras, oraciones o subpalabras, permitiendo que el sistema procese el lenguaje por partes. Por ejemplo, la oración "El gato se sentó." se convierte en ["El", "gato", "se", "sentó", "."]
Etiquetado de partes del discurso para identificar funciones de palabras: Este proceso etiqueta las palabras con sus roles gramaticales (sustantivo, verbo, adjetivo, etc.), lo cual es crucial para entender la estructura y el significado de las oraciones.
Reconocimiento de entidades nombradas para identificar objetos, personas o lugares específicos: Este proceso avanzado detecta y clasifica elementos clave en el texto, como identificar "Apple" como una empresa en lugar de una fruta o "Washington" como una persona en lugar de un lugar, basándose en pistas contextuales.
Análisis de dependencias para entender relaciones entre palabras: Esto analiza cómo las palabras en una oración se relacionan entre sí, creando una estructura en forma de árbol que muestra conexiones gramaticales.
Lematización y stemming para reducir palabras a sus formas base: Estas técnicas ayudan a estandarizar las palabras (por ejemplo, "corriendo" → "correr") para mejorar la precisión del análisis.

1.1.2 Aplicaciones del NLP

El NLP ha revolucionado numerosos campos gracias a sus diversas aplicaciones. A continuación, se presenta un análisis detallado de sus principales casos de uso:

Análisis de Sentimientos

Monitorear la salud de la marca en diferentes segmentos de mercado
Identificar tendencias emergentes en la satisfacción del cliente
Analizar la percepción de la competencia en el mercado
Medir el impacto de campañas de marketing
Detectar posibles crisis de relaciones públicas antes de que escalen

Ejemplo

Construyamos un sistema de análisis de sentimientos más sofisticado que pueda manejar múltiples aspectos del análisis de texto:

import pandas as pd
import nltk
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
from textblob import TextBlob
import re

class SentimentAnalyzer:
    def __init__(self):
        self.lemmatizer = WordNetLemmatizer()
        self.stop_words = set(stopwords.words('english'))
    
    def clean_text(self, text):
        # Remove special characters and digits
        text = re.sub(r'[^a-zA-Z\s]', '', text)
        # Convert to lowercase
        text = text.lower()
        return text
    
    def process_text(self, text):
        # Clean the text
        cleaned_text = self.clean_text(text)
        
        # Tokenize
        tokens = word_tokenize(cleaned_text)
        
        # Remove stopwords and lemmatize
        processed_tokens = [
            self.lemmatizer.lemmatize(token)
            for token in tokens
            if token not in self.stop_words
        ]
        
        return processed_tokens
    
    def analyze_sentiment(self, text):
        # Get base sentiment
        blob = TextBlob(text)
        sentiment_score = blob.sentiment.polarity
        
        # Determine sentiment category
        if sentiment_score > 0:
            category = 'Positive'
        elif sentiment_score < 0:
            category = 'Negative'
        else:
            category = 'Neutral'
        
        # Process text for additional analysis
        processed_tokens = self.process_text(text)
        
        return {
            'original_text': text,
            'processed_tokens': processed_tokens,
            'sentiment_score': sentiment_score,
            'sentiment_category': category,
            'subjectivity': blob.sentiment.subjectivity
        }

# Example usage
analyzer = SentimentAnalyzer()

# Analyze multiple examples
examples = [
    "This product is absolutely amazing! I love everything about it.",
    "The service was terrible and I'm very disappointed.",
    "The movie was okay, nothing special.",
]

for text in examples:
    results = analyzer.analyze_sentiment(text)
    print(f"\nAnalysis for: {results['original_text']}")
    print(f"Processed tokens: {results['processed_tokens']}")
    print(f"Sentiment score: {results['sentiment_score']:.2f}")
    print(f"Category: {results['sentiment_category']}")
    print(f"Subjectivity: {results['subjectivity']:.2f}")

Desglose del Código:

Estructura de la Clase: La clase SentimentAnalyzer encapsula toda la funcionalidad, lo que hace que el código sea organizado y reutilizable.
Limpieza de Texto: El método clean_text elimina caracteres especiales y normaliza el texto a minúsculas.
Procesamiento de Texto: El método process_text implementa un pipeline completo de NLP, que incluye tokenización, eliminación de palabras vacías y lematización.
Análisis de Sentimientos: El método analyze_sentiment proporciona un análisis integral que incluye:
- Cálculo de puntuación de sentimiento
- Categorización del sentimiento
- Medición de la subjetividad
- Procesamiento de tokens

Ejemplo de Salida:

Analysis for: This product is absolutely amazing! I love everything about it.
Processed tokens: ['product', 'absolutely', 'amazing', 'love', 'everything']
Sentiment score: 0.85
Category: Positive
Subjectivity: 0.75

Analysis for: The service was terrible and I'm very disappointed.
Processed tokens: ['service', 'terrible', 'disappointed']
Sentiment score: -0.65
Category: Negative
Subjectivity: 0.90

Analysis for: The movie was okay, nothing special.
Processed tokens: ['movie', 'okay', 'nothing', 'special']
Sentiment score: 0.10
Category: Positive
Subjectivity: 0.30

Traducción Automática

Las capacidades clave incluyen:

Comprensión contextual para desambiguar palabras con múltiples significados
Preservación de expresiones idiomáticas encontrando equivalentes apropiados
Adaptación de referencias culturales para mantener el significado entre diferentes sociedades
Correspondencia de estilo para mantener el tono formal/informal, lenguaje técnico o escritura creativa
Procesamiento en tiempo real de múltiples pares de idiomas simultáneamente

Ejemplo: Traducción Automática Neuronal

A continuación, se presenta una implementación de un sistema básico de traducción automática neuronal utilizando PyTorch y la arquitectura transformer:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from transformers import MarianMTModel, MarianTokenizer

class TranslationDataset(Dataset):
    def __init__(self, source_texts, target_texts, tokenizer, max_length=128):
        self.source_texts = source_texts
        self.target_texts = target_texts
        self.tokenizer = tokenizer
        self.max_length = max_length

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

    def __getitem__(self, idx):
        source = self.source_texts[idx]
        target = self.target_texts[idx]

        # Tokenize the texts
        source_tokens = self.tokenizer(
            source,
            max_length=self.max_length,
            padding="max_length",
            truncation=True,
            return_tensors="pt"
        )
        
        target_tokens = self.tokenizer(
            target,
            max_length=self.max_length,
            padding="max_length",
            truncation=True,
            return_tensors="pt"
        )

        return {
            "input_ids": source_tokens["input_ids"].squeeze(),
            "attention_mask": source_tokens["attention_mask"].squeeze(),
            "labels": target_tokens["input_ids"].squeeze()
        }

class Translator:
    def __init__(self, source_lang="en", target_lang="fr"):
        self.model_name = f"Helsinki-NLP/opus-mt-{source_lang}-{target_lang}"
        self.tokenizer = MarianTokenizer.from_pretrained(self.model_name)
        self.model = MarianMTModel.from_pretrained(self.model_name)
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.model.to(self.device)

    def translate(self, texts, batch_size=8, max_length=128):
        self.model.eval()
        translations = []

        for i in range(0, len(texts), batch_size):
            batch_texts = texts[i:i + batch_size]
            
            # Tokenize
            inputs = self.tokenizer(
                batch_texts,
                return_tensors="pt",
                padding=True,
                truncation=True,
                max_length=max_length
            ).to(self.device)

            # Generate translations
            with torch.no_grad():
                translated = self.model.generate(
                    **inputs,
                    max_length=max_length,
                    num_beams=4,
                    length_penalty=0.6,
                    early_stopping=True
                )

            # Decode the generated tokens
            decoded = self.tokenizer.batch_decode(translated, skip_special_tokens=True)
            translations.extend(decoded)

        return translations

# Example usage
if __name__ == "__main__":
    # Initialize translator (English to French)
    translator = Translator(source_lang="en", target_lang="fr")

    # Example sentences
    english_texts = [
        "Hello, how are you?",
        "Machine learning is fascinating.",
        "The weather is beautiful today."
    ]

    # Perform translation
    french_translations = translator.translate(english_texts)

    # Print results
    for en, fr in zip(english_texts, french_translations):
        print(f"English: {en}")
        print(f"French: {fr}")
        print()

Desglose del Código:

Clase TranslationDataset:
- Gestiona la preparación de datos para el entrenamiento
- Implementa la funcionalidad de un dataset personalizado para PyTorch
- Maneja la tokenización de textos de origen y destino
Clase Translator:
- Inicializa el modelo preentrenado MarianMT
- Gestiona el uso de dispositivos (CPU/GPU)
- Implementa el pipeline de traducción
Proceso de Traducción:
- Agrupa los textos de entrada en lotes para un procesamiento eficiente
- Aplica búsqueda con haz (beam search) para mejorar la calidad de la traducción
- Gestiona automáticamente la tokenización y la detokenización

Características Clave:

Utiliza el modelo MarianMT de última generación
Soporta procesamiento por lotes para mayor eficiencia
Implementa búsqueda con haz para mejorar la calidad de la traducción
Maneja múltiples oraciones simultáneamente
Administra automáticamente los recursos de memoria y cómputo

Ejemplo de Salida:

English: Hello, how are you?
French: Bonjour, comment allez-vous ?

English: Machine learning is fascinating.
French: L'apprentissage automatique est fascinant.

English: The weather is beautiful today.
French: Le temps est magnifique aujourd'hui.

Esta implementación demuestra cómo los sistemas modernos de NLP pueden realizar traducciones complejas manteniendo la estructura gramatical y el significado entre idiomas.

Resumen de Texto

Identificar temas centrales y argumentos clave en múltiples documentos
Preservar el flujo lógico y las relaciones entre ideas
Generar resúmenes de diferentes longitudes según las necesidades del usuario
Mantener la precisión factual mientras se condensa la información
Comprender la estructura del documento y la importancia de cada sección

Ejemplo: Sistema de Resumen de Texto

A continuación, se presenta una implementación de un sistema de resumen de texto extractivo utilizando técnicas modernas de NLP:

import numpy as np
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
from sklearn.feature_extraction.text import TfidfVectorizer
import networkx as nx

class TextSummarizer:
    def __init__(self):
        self.stop_words = set(stopwords.words('english'))
        self.lemmatizer = WordNetLemmatizer()
        
    def preprocess_text(self, text):
        # Tokenize into sentences
        sentences = sent_tokenize(text)
        
        # Clean and preprocess each sentence
        cleaned_sentences = []
        for sentence in sentences:
            # Tokenize words
            words = word_tokenize(sentence.lower())
            # Remove stopwords and lemmatize
            words = [
                self.lemmatizer.lemmatize(word) 
                for word in words 
                if word.isalnum() and word not in self.stop_words
            ]
            cleaned_sentences.append(' '.join(words))
            
        return sentences, cleaned_sentences
    
    def create_similarity_matrix(self, sentences):
        # Create TF-IDF vectors
        vectorizer = TfidfVectorizer()
        tfidf_matrix = vectorizer.fit_transform(sentences)
        
        # Calculate similarity matrix
        similarity_matrix = (tfidf_matrix * tfidf_matrix.T).toarray()
        return similarity_matrix
    
    def summarize(self, text, num_sentences=3):
        # Get original and preprocessed sentences
        original_sentences, cleaned_sentences = self.preprocess_text(text)
        
        if len(original_sentences) <= num_sentences:
            return ' '.join(original_sentences)
        
        # Create similarity matrix
        similarity_matrix = self.create_similarity_matrix(cleaned_sentences)
        
        # Create graph and calculate scores
        nx_graph = nx.from_numpy_array(similarity_matrix)
        scores = nx.pagerank(nx_graph)
        
        # Get top sentences
        ranked_sentences = [
            (score, sentence) 
            for sentence, score in zip(original_sentences, scores)
        ]
        ranked_sentences.sort(reverse=True)
        
        # Select top sentences while maintaining original order
        selected_indices = [
            original_sentences.index(sentence)
            for _, sentence in ranked_sentences[:num_sentences]
        ]
        selected_indices.sort()
        
        summary = ' '.join([original_sentences[i] for i in selected_indices])
        return summary

# Example usage
if __name__ == "__main__":
    text = """
    Natural Language Processing (NLP) is a branch of artificial intelligence 
    that helps computers understand human language. It combines computational 
    linguistics, machine learning, and deep learning models. NLP applications 
    include machine translation, sentiment analysis, and text summarization. 
    Modern NLP systems can process multiple languages and understand context. 
    The field continues to evolve with new transformer models and neural 
    architectures.
    """
    
    summarizer = TextSummarizer()
    summary = summarizer.summarize(text, num_sentences=2)
    print("Original Text Length:", len(text))
    print("Summary Length:", len(summary))
    print("\nSummary:")
    print(summary)

Desglose del Código:

Estructura de la Clase: La clase TextSummarizer encapsula toda la funcionalidad de resumen con una separación clara de responsabilidades.
Preprocesamiento: El método preprocess_text implementa pasos esenciales de NLP:
- Tokenización de oraciones para dividir el texto en oraciones
- Tokenización de palabras para dividir las oraciones en palabras
- Eliminación de palabras vacías y lematización para la normalización del texto
Análisis de Similitud: El método create_similarity_matrix:
- Crea vectores TF-IDF para cada oración
- Calcula la similitud entre oraciones utilizando operaciones vectoriales
Algoritmo de Resumen: El método summarize:
- Utiliza el algoritmo PageRank para puntuar la importancia de las oraciones
- Mantiene el orden original de las oraciones en el resumen
- Permite personalizar la longitud del resumen

Ejemplo de Salida:

Original Text Length: 297
Summary Length: 128

Summary: Natural Language Processing (NLP) is a branch of artificial intelligence 
that helps computers understand human language. NLP applications include machine 
translation, sentiment analysis, and text summarization.

Esta implementación demuestra cómo las técnicas modernas de NLP pueden identificar y extraer eficazmente las oraciones más importantes de un texto manteniendo la legibilidad y coherencia.

Chatbots y Asistentes Virtuales

Procesar y comprender patrones lingüísticos complejos, incluidos modismos, significados dependientes del contexto y referencias culturales
Mantener el historial de conversación para proporcionar respuestas coherentes a lo largo de múltiples intercambios de diálogo
Analizar el sentimiento y las señales emocionales en la entrada del usuario para generar respuestas emocionales apropiadas
Aprender de las interacciones para mejorar continuamente la calidad de las respuestas

Las aplicaciones en el mundo real se han expandido significativamente:

Salud: Realizar evaluaciones preliminares de síntomas, programar citas y enviar recordatorios de medicamentos
Educación: Ofrecer experiencias de aprendizaje personalizadas, responder preguntas de estudiantes y adaptar el ritmo de enseñanza según la comprensión
Atención al Cliente: Gestionar consultas en múltiples canales, resolver problemas comunes y escalar casos complejos a agentes humanos de manera fluida
Apoyo en Salud Mental: Proporcionar asesoramiento inicial accesible y apoyo emocional a través de conversaciones empáticas

Ejemplo: Construcción de un Chatbot Simple

A continuación, se presenta una implementación de un chatbot básico utilizando técnicas modernas de NLP y correspondencia de patrones:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
import re
import random

class SimpleBot:
    def __init__(self):
        # Initialize predefined responses
        self.responses = {
            'greeting': ['Hello!', 'Hi there!', 'Greetings!'],
            'farewell': ['Goodbye!', 'See you later!', 'Take care!'],
            'thanks': ["You're welcome!", 'No problem!', 'Glad I could help!'],
            'unknown': ["I'm not sure about that.", "Could you rephrase that?", 
                       "I don't understand."]
        }
        
        # Load pre-trained model and tokenizer
        self.model_name = "microsoft/DialoGPT-small"
        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
        self.model = AutoModelForCausalLM.from_pretrained(self.model_name)
        
        # Initialize conversation history
        self.conversation_history = []
        
    def preprocess_input(self, text):
        # Convert to lowercase and remove special characters
        text = text.lower()
        text = re.sub(r'[^\w\s]', '', text)
        return text
        
    def pattern_match(self, text):
        # Basic pattern matching for common phrases
        if any(word in text for word in ['hello', 'hi', 'hey']):
            return random.choice(self.responses['greeting'])
        elif any(word in text for word in ['bye', 'goodbye', 'cya']):
            return random.choice(self.responses['farewell'])
        elif any(word in text for word in ['thanks', 'thank you']):
            return random.choice(self.responses['thanks'])
        return None
        
    def generate_response(self, text):
        # Encode the input text
        inputs = self.tokenizer.encode(text + self.tokenizer.eos_token, 
                                     return_tensors='pt')
        
        # Generate response using the model
        response_ids = self.model.generate(
            inputs,
            max_length=1000,
            pad_token_id=self.tokenizer.eos_token_id,
            no_repeat_ngram_size=3,
            do_sample=True,
            top_k=100,
            top_p=0.7,
            temperature=0.8
        )
        
        # Decode the response
        response = self.tokenizer.decode(response_ids[:, inputs.shape[-1]:][0], 
                                       skip_special_tokens=True)
        return response
        
    def chat(self, user_input):
        # Preprocess input
        processed_input = self.preprocess_input(user_input)
        
        # Try pattern matching first
        response = self.pattern_match(processed_input)
        
        if not response:
            try:
                # Generate response using the model
                response = self.generate_response(user_input)
            except Exception as e:
                response = random.choice(self.responses['unknown'])
        
        # Update conversation history
        self.conversation_history.append((user_input, response))
        return response

# Example usage
if __name__ == "__main__":
    bot = SimpleBot()
    print("Bot: Hello! How can I help you today? (type 'quit' to exit)")
    
    while True:
        user_input = input("You: ")
        if user_input.lower() == 'quit':
            print("Bot: Goodbye!")
            break
            
        response = bot.chat(user_input)
        print(f"Bot: {response}")

Desglose del Código:

Estructura de la Clase:
- Implementa una clase SimpleBot que inicializa un modelo preentrenado y plantillas de respuesta.
- Mantiene un historial de conversación para la conciencia del contexto.
- Utiliza enfoques basados en reglas y neuronales para generar respuestas.
Procesamiento de Entrada:
- Preprocesa la entrada del usuario mediante normalización de texto.
- Implementa correspondencia de patrones para frases comunes.
- Maneja casos límite y excepciones de forma elegante.
Generación de Respuestas:
- Utiliza el modelo DialoGPT para generar respuestas contextuales.
- Implementa sampling con temperatura y top-k/top-p para diversificar las respuestas.
- Incluye respuestas de respaldo para manejar entradas inesperadas.

Características Clave:

Enfoque híbrido que combina generación de respuestas basadas en reglas y neuronales.
Comprensión contextual mediante historial de conversación.
Parámetros configurables de respuesta para controlar la calidad del output.
Manejo de errores y degradación elegante.

Interacción de Ejemplo:

Bot: Hello! How can I help you today? (type 'quit' to exit)
You: Hi there!
Bot: Hello! How are you doing today?
You: I'm doing great, thanks for asking!
Bot: That's wonderful to hear! Is there anything specific you'd like to chat about?
You: Can you tell me about machine learning?
Bot: Machine learning is a fascinating field of AI that allows computers to learn from data...
You: quit
Bot: Goodbye!

Esta implementación demuestra cómo los chatbots modernos combinan sistemas basados en reglas con modelos de lenguaje neuronal para crear conversaciones más naturales y atractivas.

Generación de Contenido

Generar contenido contextualmente apropiado al comprender terminología específica de la industria y convenciones de escritura
Adaptar el estilo de escritura según la demografía del público objetivo, desde publicaciones informales en blogs hasta documentos académicos formales
Crear variaciones de contenido para diferentes plataformas mientras preservan el mensaje principal
Asistir en tareas de escritura creativa sugiriendo desarrollos de la trama, descripciones de personajes y diálogos
Auto-generar informes, resúmenes y documentación a partir de datos estructurados

Ejemplo: Generación de Contenido con GPT

A continuación, se presenta una implementación de un generador de contenido que puede crear diferentes tipos de contenido con estilos y tonos específicos:

from openai import OpenAI
import os

class ContentGenerator:
    def __init__(self):
        # Initialize OpenAI client
        self.client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
        
        # Define content styles
        self.styles = {
            'formal': "In a professional and academic tone, ",
            'casual': "In a friendly and conversational way, ",
            'technical': "Using technical terminology, ",
            'creative': "In a creative and engaging style, "
        }
        
    def generate_content(self, prompt, style='formal', max_length=500, 
                        temperature=0.7):
        try:
            # Apply style to prompt
            styled_prompt = self.styles.get(style, "") + prompt
            
            # Generate content using GPT-4
            response = self.client.chat.completions.create(
                model="gpt-4",
                messages=[
                    {"role": "system", "content": "You are a professional content writer."},
                    {"role": "user", "content": styled_prompt}
                ],
                max_tokens=max_length,
                temperature=temperature,
                top_p=0.95,
                frequency_penalty=0.5,
                presence_penalty=0.5
            )
            
            # Extract and clean up the generated text
            generated_text = response.choices[0].message.content
            return self.clean_text(generated_text)
            
        except Exception as e:
            return f"Error generating content: {str(e)}"
    
    def clean_text(self, text):
        # Remove the style prompt if present
        for style_prompt in self.styles.values():
            if text.startswith(style_prompt):
                text = text[len(style_prompt):]
        return text.strip()
    
    def generate_article(self, topic, style='formal', sections=3):
        """Generate a structured article with multiple sections"""
        article = []
        
        # Generate introduction
        intro_prompt = f"Write an introduction about {topic}"
        article.append(self.generate_content(intro_prompt, style, 200))
        
        # Generate main sections
        for i in range(sections):
            section_prompt = f"Write section {i+1} about {topic}"
            article.append(self.generate_content(section_prompt, style, 300))
        
        # Generate conclusion
        conclusion_prompt = f"Write a conclusion about {topic}"
        article.append(self.generate_content(conclusion_prompt, style, 200))
        
        return "\n\n".join(article)

# Example usage
if __name__ == "__main__":
    # Ensure you have set your OpenAI API key in environment variables
    if not os.getenv('OPENAI_API_KEY'):
        print("Please set your OPENAI_API_KEY environment variable")
        exit(1)
        
    generator = ContentGenerator()
    
    # Generate a blog post
    topic = "The Impact of Artificial Intelligence on Healthcare"
    print("Generating article...")
    article = generator.generate_article(
        topic,
        style='technical',
        sections=3
    )
    print("\nGenerated Article:")
    print(article)

Desglosemos la implementación de la clase ContentGenerator:

1. Inicialización y Estructura de la Clase

La clase utiliza la API de OpenAI para la generación de contenido.
Define diferentes estilos de contenido (formal, informal, técnico, creativo) con instrucciones de tono correspondientes.

2. Métodos Principales

La clase cuenta con tres métodos principales:

generate_content():
- Recibe un prompt, estilo y parámetros para la generación de contenido.
- Utiliza GPT-4 para generar contenido con los parámetros especificados.
- Incluye manejo de errores y limpieza de texto.
clean_text():
- Elimina las indicaciones de estilo del texto generado.
- Devuelve el texto limpio y sin formato adicional.
generate_article():
- Crea un artículo estructurado con introducción, secciones principales y conclusión.
- Permite la personalización del estilo y el número de secciones.
- Combina múltiples generaciones de contenido en una pieza cohesiva.

3. Características Clave

Control de temperatura (0.7) para equilibrar la creatividad.
Penalizaciones de frecuencia y presencia para reducir repeticiones.
Uso de variables de entorno para la seguridad de la clave API.
Manejo de errores estructurado a lo largo del proceso de generación.

4. Ejemplo de Uso

El código incluye un ejemplo práctico que:

Verifica la configuración adecuada de la clave API.
Genera un artículo técnico sobre la IA en la atención médica.
Crea una pieza estructurada con múltiples secciones.

Ejemplo de Salida:

Artículo Generado: El Impacto de la Inteligencia Artificial en la Atención Médica

The integration of Artificial Intelligence (AI) in healthcare represents a revolutionary transformation in medical practice and patient care. Recent advancements in machine learning algorithms and data analytics have enabled healthcare providers to leverage AI technologies for improved diagnosis, treatment planning, and patient outcomes. This technological evolution promises to enhance healthcare delivery while reducing costs and improving accessibility.

The primary impact of AI in healthcare is evident in diagnostic accuracy and efficiency. Machine learning algorithms can analyze medical imaging data with remarkable precision, helping radiologists detect abnormalities in X-rays, MRIs, and CT scans. These AI systems can process vast amounts of imaging data in seconds, highlighting potential areas of concern and providing probability scores for various conditions. This capability not only accelerates the diagnostic process but also reduces the likelihood of human error.

Patient care and monitoring have been revolutionized through AI-powered systems. Smart devices and wearable technologies equipped with AI algorithms can continuously monitor vital signs, predict potential health complications, and alert healthcare providers to emergency situations before they become critical. This proactive approach to patient care has shown significant promise in reducing hospital readmission rates and improving patient outcomes, particularly for those with chronic conditions.

In conclusion, AI's integration into healthcare systems represents a paradigm shift in medical practice. While challenges remain regarding data privacy, regulatory compliance, and ethical considerations, the potential benefits of AI in healthcare are undeniable. As technology continues to evolve, we can expect AI to play an increasingly central role in shaping the future of healthcare delivery and patient care.

Extracción de Información

Estas capacidades hacen que la extracción de información sea esencial para:

La síntesis automatizada de investigaciones, procesando miles de artículos académicos para extraer hallazgos clave
El análisis de documentos legales, permitiendo la revisión rápida de contratos y jurisprudencia
El procesamiento de registros médicos, extrayendo historiales de pacientes, diagnósticos y planes de tratamiento a partir de notas clínicas
La inteligencia empresarial, recopilando información competitiva de artículos de noticias e informes

Aquí tienes un ejemplo completo de extracción de información utilizando spaCy:

import spacy
import pandas as pd
from typing import List, Dict

class InformationExtractor:
    def __init__(self):
        # Load English language model
        self.nlp = spacy.load("en_core_web_sm")
        
    def extract_entities(self, text: str) -> List[Dict]:
        """Extract named entities from text."""
        doc = self.nlp(text)
        entities = []
        
        for ent in doc.ents:
            entities.append({
                'text': ent.text,
                'label': ent.label_,
                'start': ent.start_char,
                'end': ent.end_char
            })
        
        return entities
    
    def extract_relationships(self, text: str) -> List[Dict]:
        """Extract relationships between entities."""
        doc = self.nlp(text)
        relationships = []
        
        for token in doc:
            if token.dep_ in ('nsubj', 'dobj'):  # subject or object
                subject = token.text
                verb = token.head.text
                obj = [w.text for w in token.head.children if w.dep_ == 'dobj']
                
                if obj:
                    relationships.append({
                        'subject': subject,
                        'verb': verb,
                        'object': obj[0]
                    })
        
        return relationships
    
    def extract_key_phrases(self, text: str) -> List[str]:
        """Extract important phrases based on dependency parsing."""
        doc = self.nlp(text)
        phrases = []
        
        for chunk in doc.noun_chunks:
            if chunk.root.dep_ in ('nsubj', 'dobj', 'pobj'):
                phrases.append(chunk.text)
                
        return phrases

# Example usage
if __name__ == "__main__":
    extractor = InformationExtractor()
    
    sample_text = """
    Apple Inc. CEO Tim Cook announced a new iPhone launch in Cupertino, 
    California on September 12, 2024. The event will showcase revolutionary 
    AI features. Microsoft and Google are also planning similar events.
    """
    
    # Extract entities
    entities = extractor.extract_entities(sample_text)
    print("\nExtracted Entities:")
    print(pd.DataFrame(entities))
    
    # Extract relationships
    relationships = extractor.extract_relationships(sample_text)
    print("\nExtracted Relationships:")
    print(pd.DataFrame(relationships))
    
    # Extract key phrases
    phrases = extractor.extract_key_phrases(sample_text)
    print("\nKey Phrases:")
    print(phrases)

Analicemos la clase InformationExtractor que utiliza spaCy para el procesamiento de lenguaje natural:

1. Configuración de la Clase y Dependencias

Utiliza spaCy para el procesamiento de NLP y pandas para la manipulación de datos.
Se inicializa con el modelo de lenguaje en inglés de spaCy (en_core_web_sm).

2. Métodos Principales

La clase contiene tres métodos clave de extracción:

extract_entities():
- Identifica entidades nombradas en el texto.
- Devuelve una lista de diccionarios con el texto de la entidad, la etiqueta y la posición.
- Captura elementos como organizaciones, personas y ubicaciones.
extract_relationships():
- Encuentra conexiones entre sujetos y objetos.
- Utiliza análisis de dependencias para identificar relaciones.
- Devuelve relaciones sujeto-verbo-objeto.
extract_key_phrases():
- Extrae frases nominales importantes.
- Utiliza análisis de dependencias para identificar frases significativas.
- Se centra en sujetos, objetos y objetos preposicionales.

3. Ejemplo de Uso

El código demuestra una aplicación práctica con un texto de ejemplo sobre Apple Inc. y muestra tres tipos de salida:

Entidades: Identifica compañías (Apple Inc., Microsoft, Google), personas (Tim Cook), ubicaciones (Cupertino, California) y fechas.
Relaciones: Extrae conexiones sujeto-verbo-objeto como "Cook announced launch".
Frases Clave: Extrae frases nominales importantes del texto.

4. Características Clave

Utiliza modelos preentrenados para un reconocimiento preciso de entidades.
Implementa análisis de dependencias para la extracción de relaciones.
Puede manejar estructuras de oraciones complejas.
Produce datos estructurados adecuados para análisis posteriores.

Ejemplo de Salida:

# Extracted Entities:
#              text     label  start  end
# 0        Apple Inc.     ORG      1   10
# 1        Tim Cook    PERSON     15   23
# 2        Cupertino     GPE     47   56
# 3      California     GPE     58   68
# 4    September 12     DATE     72   84
# 5            2024     DATE     86   90
# 6       Microsoft     ORG    146  154
# 7          Google     ORG    159  165

# Extracted Relationships:
#    subject    verb     object
# 0     Cook announced   launch
# 1    event     will  showcase

# Key Phrases:
# ['Apple Inc. CEO', 'new iPhone launch', 'revolutionary AI features', 
#  'similar events']

Características Clave:

Utiliza modelos preentrenados de spaCy para un reconocimiento preciso de entidades.
Implementa análisis de dependencias para la extracción de relaciones.
Maneja estructuras de oraciones complejas y múltiples tipos de entidades.
Devuelve datos estructurados adecuados para análisis posteriores.

Aplicaciones:

Análisis automatizado de documentos en contextos legales y empresariales.
Monitoreo de noticias y redes sociales.
Análisis de artículos de investigación y extracción de conocimiento.
Análisis de comentarios y opiniones de clientes.

1.1.3 Un Flujo de Trabajo Simple de NLP

Para ver NLP en acción, consideremos un ejemplo sencillo: analizar el sentimiento de una oración.

Oración: I love this book; it’s truly inspiring!

Flujo de Trabajo:

Tokenización: Dividir la oración en palabras individuales o tokens:

from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords
from nltk import pos_tag
import string

def analyze_text(text):
    # Sentence tokenization
    sentences = sent_tokenize(text)
    print("\n1. Sentence Tokenization:")
    print(sentences)
    
    # Word tokenization
    tokens = word_tokenize(text)
    print("\n2. Word Tokenization:")
    print(tokens)
    
    # Remove punctuation
    tokens_no_punct = [token for token in tokens if token not in string.punctuation]
    print("\n3. After Punctuation Removal:")
    print(tokens_no_punct)
    
    # Convert to lowercase and remove stopwords
    stop_words = set(stopwords.words('english'))
    clean_tokens = [token.lower() for token in tokens_no_punct 
                   if token.lower() not in stop_words]
    print("\n4. After Stopword Removal:")
    print(clean_tokens)
    
    # Part-of-speech tagging
    pos_tags = pos_tag(tokens)
    print("\n5. Part-of-Speech Tags:")
    print(pos_tags)

# Example usage
text = "I love this book; it's truly inspiring! The author writes beautifully."
analyze_text(text)

# Output:
# 1. Sentence Tokenization:
# ['I love this book; it's truly inspiring!', 'The author writes beautifully.']

# 2. Word Tokenization:
# ['I', 'love', 'this', 'book', ';', 'it', ''', 's', 'truly', 'inspiring', '!', 
#  'The', 'author', 'writes', 'beautifully', '.']

# 3. After Punctuation Removal:
# ['I', 'love', 'this', 'book', 'it', 's', 'truly', 'inspiring', 
#  'The', 'author', 'writes', 'beautifully']

# 4. After Stopword Removal:
# ['love', 'book', 'truly', 'inspiring', 'author', 'writes', 'beautifully']

# 5. Part-of-Speech Tags:
# [('I', 'PRP'), ('love', 'VBP'), ('this', 'DT'), ('book', 'NN'), ...]

Desglose del Código:

Importaciones:
- word_tokenize, sent_tokenize: Para dividir el texto en palabras y oraciones.
- stopwords: Para eliminar palabras comunes.
- pos_tag: Para etiquetado de partes del discurso (POS).
- string: Para acceder a los signos de puntuación.
Función analyze_text:
- Recibe una cadena de texto como entrada.
- Procesa el texto a través de múltiples pasos de NLP.
- Imprime los resultados en cada etapa.
Pasos de Procesamiento:
- Tokenización de Oraciones: Divide el texto en oraciones individuales.
- Tokenización de Palabras: Divide las oraciones en palabras o tokens individuales.
- Eliminación de Puntuación: Filtra los signos de puntuación.
- Eliminación de Palabras Vacías: Elimina palabras comunes y convierte el texto a minúsculas.
- Etiquetado POS: Etiqueta cada palabra con su parte del discurso correspondiente.

Características Clave:

Maneja múltiples oraciones.
Mantiene el orden de procesamiento para un análisis claro del texto.
Demuestra múltiples capacidades de NLTK.
Incluye salidas detalladas en cada paso.

Eliminación de Palabras Vacías: Un paso crucial de preprocesamiento que mejora el análisis de texto al eliminar palabras comunes (stopwords) que tienen un valor semántico mínimo. Estas incluyen artículos (a, an, the), pronombres (I, you, it), preposiciones (in, at, on) y ciertos verbos auxiliares (is, are, was). Al eliminar estas palabras de alta frecuencia pero baja información, podemos centrarnos en los términos portadores de contenido que realmente transmiten el significado del mensaje. Este proceso mejora significativamente la eficiencia de tareas como modelado de temas, clasificación de documentos y recuperación de información.

from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
import string

def process_text(text):
    # Step 1: Tokenize the text
    tokens = word_tokenize(text)
    print("Original tokens:", tokens)
    
    # Step 2: Convert to lowercase
    tokens_lower = [token.lower() for token in tokens]
    print("\nLowercase tokens:", tokens_lower)
    
    # Step 3: Remove punctuation
    tokens_no_punct = [token for token in tokens_lower 
                      if token not in string.punctuation]
    print("\nTokens without punctuation:", tokens_no_punct)
    
    # Step 4: Remove stopwords
    stop_words = set(stopwords.words('english'))
    filtered_tokens = [token for token in tokens_no_punct 
                      if token not in stop_words]
    print("\nTokens without stopwords:", filtered_tokens)
    
    # Step 5: Get frequency distribution
    from collections import Counter
    word_freq = Counter(filtered_tokens)
    print("\nWord frequencies:", dict(word_freq))
    
    return filtered_tokens

# Example usage
text = "I love this inspiring book; it's truly amazing!"
processed_tokens = process_text(text)

# Output:
# Original tokens: ['I', 'love', 'this', 'inspiring', 'book', ';', 'it', "'s", 'truly', 'amazing', '!']
# Lowercase tokens: ['i', 'love', 'this', 'inspiring', 'book', ';', 'it', "'s", 'truly', 'amazing', '!']
# Tokens without punctuation: ['i', 'love', 'this', 'inspiring', 'book', 'it', 's', 'truly', 'amazing']
# Tokens without stopwords: ['love', 'inspiring', 'book', 'truly', 'amazing']
# Word frequencies: {'love': 1, 'inspiring': 1, 'book': 1, 'truly': 1, 'amazing': 1}

Desglose del Código:

Importaciones:
- stopwords: Acceso a las palabras vacías comunes del inglés.
- word_tokenize: Para dividir el texto en palabras.
- string: Para acceder a los signos de puntuación.
Función process_text:
- Recibe texto sin procesar como entrada.
- Realiza el procesamiento del texto paso a paso.
- Imprime los resultados en cada etapa para mayor claridad.
Pasos de Procesamiento:
- Tokenización: Divide el texto en palabras individuales.
- Normalización de Mayúsculas y Minúsculas: Convierte todo el texto a minúsculas.
- Eliminación de Puntuación: Elimina todos los signos de puntuación.
- Eliminación de Palabras Vacías: Filtra las palabras comunes.
- Análisis de Frecuencia: Cuenta las ocurrencias de las palabras.
Mejoras Clave:
- Se añadió una visualización paso a paso.
- Se incluyó el análisis de frecuencia.
- Se mejoró la organización del código.
- Se añadió documentación completa.
Análisis de Sentimientos:
Un paso crucial que evalúa el tono emocional del texto al analizar la elección de palabras y el contexto. Este proceso asigna valores numéricos para expresar la positividad, negatividad o neutralidad del contenido. Usando técnicas avanzadas de procesamiento de lenguaje natural, el análisis de sentimientos puede detectar matices emocionales sutiles, sarcasmo y estados emocionales complejos. En nuestro flujo de trabajo, aplicamos el análisis de sentimientos al texto filtrado después de pasos de preprocesamiento como tokenización y eliminación de palabras vacías para garantizar una evaluación emocional más precisa.

from textblob import TextBlob
import numpy as np
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords

def analyze_sentiment(text):
    # Initialize stopwords
    stop_words = set(stopwords.words('english'))
    
    # Tokenize and filter
    tokens = word_tokenize(text)
    filtered_tokens = [word for word in tokens if word.lower() not in stop_words]
    
    # Create TextBlob object
    blob = TextBlob(" ".join(filtered_tokens))
    
    # Get sentiment scores
    polarity = blob.sentiment.polarity
    subjectivity = blob.sentiment.subjectivity
    
    # Determine sentiment category
    if polarity > 0:
        category = "Positive"
    elif polarity < 0:
        category = "Negative"
    else:
        category = "Neutral"
    
    # Return detailed analysis
    return {
        'polarity': polarity,
        'subjectivity': subjectivity,
        'category': category,
        'filtered_tokens': filtered_tokens
    }

# Example usage
text = "I absolutely love this amazing book! It's truly inspiring and enlightening."
results = analyze_sentiment(text)

print(f"Original Text: {text}")
print(f"Filtered Tokens: {results['filtered_tokens']}")
print(f"Sentiment Polarity: {results['polarity']:.2f}")
print(f"Subjectivity Score: {results['subjectivity']:.2f}")
print(f"Sentiment Category: {results['category']}")

# Output:
# Original Text: I absolutely love this amazing book! It's truly inspiring and enlightening.
# Filtered Tokens: ['absolutely', 'love', 'amazing', 'book', 'truly', 'inspiring', 'enlightening']
# Sentiment Polarity: 0.85
# Subjectivity Score: 0.75
# Sentiment Category: Positive

Desglose del Código:

Importaciones:
- TextBlob: Para análisis de sentimientos.
- numpy: Para operaciones numéricas.
- Componentes de NLTK: Para el preprocesamiento de texto.
Función analyze_sentiment:
- Recibe texto sin procesar como entrada.
- Elimina palabras vacías para un análisis más limpio.
- Calcula tanto la polaridad como los puntajes de subjetividad.
- Categoriza el sentimiento como Positivo, Negativo o Neutral.
Características Clave:
- Preprocesamiento completo con eliminación de palabras vacías.
- Múltiples métricas de sentimiento (polaridad y subjetividad).
- Categorización clara del sentimiento.
- Resultados detallados en formato de diccionario.
Explicación de la Salida:
- Polaridad: Rango de -1 (negativo) a 1 (positivo).
- Subjetividad: Rango de 0 (objetivo) a 1 (subjetivo).
- Categoría: Clasificación simple del sentimiento general.

1.1.4 NLP en la Vida Cotidiana

Ejercicio Práctico: Crear un Pipeline Simple de NLP

Construyamos un pipeline básico de NLP que combine los pasos discutidos:

from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords
from textblob import TextBlob
import string
from collections import Counter
import re

class TextAnalyzer:
    def __init__(self):
        self.stop_words = set(stopwords.words('english'))
        
    def preprocess_text(self, text):
        # Remove special characters and digits
        text = re.sub(r'[^\w\s]', '', text)
        
        # Convert to lowercase
        text = text.lower()
        
        return text
        
    def analyze_text(self, text):
        # Store original text
        original_text = text
        
        # Step 1: Preprocess
        text = self.preprocess_text(text)
        
        # Step 2: Sentence tokenization
        sentences = sent_tokenize(text)
        
        # Step 3: Word tokenization
        tokens = word_tokenize(text)
        
        # Step 4: Remove stopwords
        filtered_tokens = [word for word in tokens if word not in self.stop_words]
        
        # Step 5: Calculate word frequency
        word_freq = Counter(filtered_tokens)
        
        # Step 6: Sentiment analysis
        blob = TextBlob(original_text)
        sentiment = blob.sentiment
        
        # Step 7: Return comprehensive analysis
        return {
            'original_text': original_text,
            'sentences': sentences,
            'tokens': tokens,
            'filtered_tokens': filtered_tokens,
            'word_frequency': dict(word_freq),
            'sentiment_polarity': sentiment.polarity,
            'sentiment_subjectivity': sentiment.subjectivity,
            'sentence_count': len(sentences),
            'word_count': len(tokens),
            'unique_words': len(set(tokens))
        }

def main():
    analyzer = TextAnalyzer()
    
    # Get input from user
    text = input("Enter text to analyze: ")
    
    # Perform analysis
    results = analyzer.analyze_text(text)
    
    # Display results
    print("\n=== Text Analysis Results ===")
    print(f"\nOriginal Text: {results['original_text']}")
    print(f"\nNumber of Sentences: {results['sentence_count']}")
    print(f"Total Words: {results['word_count']}")
    print(f"Unique Words: {results['unique_words']}")
    print("\nTokens:", results['tokens'])
    print("\nFiltered Tokens (stopwords removed):", results['filtered_tokens'])
    print("\nWord Frequency:", results['word_frequency'])
    print(f"\nSentiment Analysis:")
    print(f"Polarity: {results['sentiment_polarity']:.2f} (-1 negative to 1 positive)")
    print(f"Subjectivity: {results['sentiment_subjectivity']:.2f} (0 objective to 1 subjective)")

if __name__ == "__main__":
    main()

Desglose del Código:

Estructura de la Clase:
- La clase TextAnalyzer encapsula toda la funcionalidad de análisis.
- La inicialización configura las palabras vacías para reutilización.
- Los métodos están organizados para una clara separación de responsabilidades.
Componentes Clave:
- preprocess_text: Limpia y normaliza el texto de entrada.
- analyze_text: Método principal que realiza un análisis integral.
- main: Gestiona la interacción con el usuario y la visualización de resultados.
Características del Análisis:
- Tokenización de oraciones para análisis estructural.
- Tokenización de palabras y eliminación de palabras vacías.
- Cálculo de frecuencia de palabras.
- Análisis de sentimientos (polaridad y subjetividad).
- Estadísticas del texto (conteo de palabras, palabras únicas, etc.).
Mejoras sobre el Original:
- Diseño orientado a objetos para mejor organización.
- Métricas de análisis de texto más completas.
- Mejor manejo de errores y preprocesamiento del texto.
- Formateo detallado de la salida.
- Estructura de clase reutilizable.

Este ejemplo proporciona un pipeline robusto y completo de análisis de texto, adecuado tanto para fines educativos como para aplicaciones prácticas.

1.1.5 Conclusiones Clave

El NLP permite que las máquinas comprendan e interactúen con el lenguaje humano, una capacidad fundamental que les permite procesar, analizar y generar texto de forma similar a los humanos. A través de algoritmos sofisticados y modelos de aprendizaje automático, los sistemas de NLP pueden comprender el contexto, el sentimiento e incluso matices lingüísticos sutiles.
Las técnicas fundamentales del NLP incluyen:
- Tokenización: Divide el texto en unidades significativas (palabras u oraciones).
- Eliminación de Palabras Vacías: Filtra palabras comunes para centrarse en contenido significativo.
- Análisis de Sentimientos: Determina el tono emocional y el significado subjetivo.
Aplicaciones del NLP en el mundo real:
- Chatbots que proporcionan atención al cliente e información.
- Sistemas de traducción automática que superan barreras lingüísticas.
- Herramientas de resumen de texto que condensan documentos extensos.
- Asistentes de voz que comprenden y responden al habla natural.
- Sistemas de recomendación de contenido que analizan preferencias de los usuarios.

1.1 ¿Qué es el NLP?

Comencemos con lo básico: ¿Qué es el NLP?

1.1.1 Componentes clave del NLP

Para entender el NLP, es útil descomponerlo en sus componentes principales, que trabajan juntos para crear un sistema integral para procesar el lenguaje humano:

1. Comprensión del Lenguaje Natural (NLU)

Análisis semántico para entender significados y relaciones entre palabras: Esto incluye mapear palabras a sus definiciones, identificar sinónimos y entender cómo las palabras se relacionan para crear significado. Por ejemplo, reconocer que "vehículo" y "automóvil" son conceptos relacionados.
Análisis sintáctico para descomponer la estructura de las oraciones: Esto separa las oraciones en sus componentes gramaticales (sustantivos, verbos, adjetivos, etc.) y entiende cómo trabajan juntos. Ayuda a las máquinas a diferenciar entre oraciones como "El gato persiguió al ratón" y "El ratón persiguió al gato."
Comprensión contextual para captar significados situacionales: Va más allá de la interpretación literal para entender significados basados en el contexto circundante. Por ejemplo, reconocer que "Hace frío" podría ser una declaración sobre la temperatura o una solicitud para cerrar una ventana, dependiendo de la situación.
Detección de sentimientos para identificar matices emocionales: Analiza el contenido emocional en el texto, desde expresiones evidentes como "¡Me encanta esto!" hasta indicadores más sutiles de estado de ánimo, tono y actitud en comunicaciones complejas.

2. Generación de Lenguaje Natural (NLG)

Planificación de contenido para determinar qué información transmitir: Esto implica seleccionar datos relevantes, organizarlos en una secuencia lógica y decidir cómo presentarlos de manera efectiva según la audiencia y los objetivos de comunicación.
Estructuración de oraciones para crear una salida gramaticalmente correcta: Este proceso aplica reglas lingüísticas para construir oraciones bien formadas, considerando factores como la concordancia sujeto-verbo, el uso adecuado de artículos y preposiciones, y el tiempo verbal apropiado.
Respuestas contextualmente conscientes que coinciden con el flujo de la conversación: El sistema mantiene la coherencia rastreando el historial del diálogo, la intención del usuario e intercambios previos para generar respuestas naturales y relevantes.
Síntesis de lenguaje natural que suene humano: Los sistemas avanzados de NLG emplean algoritmos sofisticados para variar la estructura de las oraciones, incorporar transiciones adecuadas y mantener un tono y estilo consistentes que imiten patrones de comunicación humana.

3. Procesamiento de texto

Este componente forma la base del análisis del lenguaje al descomponer y analizar texto mediante varios procesos críticos:

Tokenización para dividir el texto en unidades manejables: Esto implica dividir el texto en palabras, oraciones o subpalabras, permitiendo que el sistema procese el lenguaje por partes. Por ejemplo, la oración "El gato se sentó." se convierte en ["El", "gato", "se", "sentó", "."]
Etiquetado de partes del discurso para identificar funciones de palabras: Este proceso etiqueta las palabras con sus roles gramaticales (sustantivo, verbo, adjetivo, etc.), lo cual es crucial para entender la estructura y el significado de las oraciones.
Reconocimiento de entidades nombradas para identificar objetos, personas o lugares específicos: Este proceso avanzado detecta y clasifica elementos clave en el texto, como identificar "Apple" como una empresa en lugar de una fruta o "Washington" como una persona en lugar de un lugar, basándose en pistas contextuales.
Análisis de dependencias para entender relaciones entre palabras: Esto analiza cómo las palabras en una oración se relacionan entre sí, creando una estructura en forma de árbol que muestra conexiones gramaticales.
Lematización y stemming para reducir palabras a sus formas base: Estas técnicas ayudan a estandarizar las palabras (por ejemplo, "corriendo" → "correr") para mejorar la precisión del análisis.

1.1.2 Aplicaciones del NLP

El NLP ha revolucionado numerosos campos gracias a sus diversas aplicaciones. A continuación, se presenta un análisis detallado de sus principales casos de uso:

Análisis de Sentimientos

Monitorear la salud de la marca en diferentes segmentos de mercado
Identificar tendencias emergentes en la satisfacción del cliente
Analizar la percepción de la competencia en el mercado
Medir el impacto de campañas de marketing
Detectar posibles crisis de relaciones públicas antes de que escalen

Ejemplo

Construyamos un sistema de análisis de sentimientos más sofisticado que pueda manejar múltiples aspectos del análisis de texto:

import pandas as pd
import nltk
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
from textblob import TextBlob
import re

class SentimentAnalyzer:
    def __init__(self):
        self.lemmatizer = WordNetLemmatizer()
        self.stop_words = set(stopwords.words('english'))
    
    def clean_text(self, text):
        # Remove special characters and digits
        text = re.sub(r'[^a-zA-Z\s]', '', text)
        # Convert to lowercase
        text = text.lower()
        return text
    
    def process_text(self, text):
        # Clean the text
        cleaned_text = self.clean_text(text)
        
        # Tokenize
        tokens = word_tokenize(cleaned_text)
        
        # Remove stopwords and lemmatize
        processed_tokens = [
            self.lemmatizer.lemmatize(token)
            for token in tokens
            if token not in self.stop_words
        ]
        
        return processed_tokens
    
    def analyze_sentiment(self, text):
        # Get base sentiment
        blob = TextBlob(text)
        sentiment_score = blob.sentiment.polarity
        
        # Determine sentiment category
        if sentiment_score > 0:
            category = 'Positive'
        elif sentiment_score < 0:
            category = 'Negative'
        else:
            category = 'Neutral'
        
        # Process text for additional analysis
        processed_tokens = self.process_text(text)
        
        return {
            'original_text': text,
            'processed_tokens': processed_tokens,
            'sentiment_score': sentiment_score,
            'sentiment_category': category,
            'subjectivity': blob.sentiment.subjectivity
        }

# Example usage
analyzer = SentimentAnalyzer()

# Analyze multiple examples
examples = [
    "This product is absolutely amazing! I love everything about it.",
    "The service was terrible and I'm very disappointed.",
    "The movie was okay, nothing special.",
]

for text in examples:
    results = analyzer.analyze_sentiment(text)
    print(f"\nAnalysis for: {results['original_text']}")
    print(f"Processed tokens: {results['processed_tokens']}")
    print(f"Sentiment score: {results['sentiment_score']:.2f}")
    print(f"Category: {results['sentiment_category']}")
    print(f"Subjectivity: {results['subjectivity']:.2f}")

Desglose del Código:

Estructura de la Clase: La clase SentimentAnalyzer encapsula toda la funcionalidad, lo que hace que el código sea organizado y reutilizable.
Limpieza de Texto: El método clean_text elimina caracteres especiales y normaliza el texto a minúsculas.
Procesamiento de Texto: El método process_text implementa un pipeline completo de NLP, que incluye tokenización, eliminación de palabras vacías y lematización.
Análisis de Sentimientos: El método analyze_sentiment proporciona un análisis integral que incluye:
- Cálculo de puntuación de sentimiento
- Categorización del sentimiento
- Medición de la subjetividad
- Procesamiento de tokens

Ejemplo de Salida:

Analysis for: This product is absolutely amazing! I love everything about it.
Processed tokens: ['product', 'absolutely', 'amazing', 'love', 'everything']
Sentiment score: 0.85
Category: Positive
Subjectivity: 0.75

Analysis for: The service was terrible and I'm very disappointed.
Processed tokens: ['service', 'terrible', 'disappointed']
Sentiment score: -0.65
Category: Negative
Subjectivity: 0.90

Analysis for: The movie was okay, nothing special.
Processed tokens: ['movie', 'okay', 'nothing', 'special']
Sentiment score: 0.10
Category: Positive
Subjectivity: 0.30

Traducción Automática

Las capacidades clave incluyen:

Comprensión contextual para desambiguar palabras con múltiples significados
Preservación de expresiones idiomáticas encontrando equivalentes apropiados
Adaptación de referencias culturales para mantener el significado entre diferentes sociedades
Correspondencia de estilo para mantener el tono formal/informal, lenguaje técnico o escritura creativa
Procesamiento en tiempo real de múltiples pares de idiomas simultáneamente

Ejemplo: Traducción Automática Neuronal

A continuación, se presenta una implementación de un sistema básico de traducción automática neuronal utilizando PyTorch y la arquitectura transformer:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from transformers import MarianMTModel, MarianTokenizer

class TranslationDataset(Dataset):
    def __init__(self, source_texts, target_texts, tokenizer, max_length=128):
        self.source_texts = source_texts
        self.target_texts = target_texts
        self.tokenizer = tokenizer
        self.max_length = max_length

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

    def __getitem__(self, idx):
        source = self.source_texts[idx]
        target = self.target_texts[idx]

        # Tokenize the texts
        source_tokens = self.tokenizer(
            source,
            max_length=self.max_length,
            padding="max_length",
            truncation=True,
            return_tensors="pt"
        )
        
        target_tokens = self.tokenizer(
            target,
            max_length=self.max_length,
            padding="max_length",
            truncation=True,
            return_tensors="pt"
        )

        return {
            "input_ids": source_tokens["input_ids"].squeeze(),
            "attention_mask": source_tokens["attention_mask"].squeeze(),
            "labels": target_tokens["input_ids"].squeeze()
        }

class Translator:
    def __init__(self, source_lang="en", target_lang="fr"):
        self.model_name = f"Helsinki-NLP/opus-mt-{source_lang}-{target_lang}"
        self.tokenizer = MarianTokenizer.from_pretrained(self.model_name)
        self.model = MarianMTModel.from_pretrained(self.model_name)
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.model.to(self.device)

    def translate(self, texts, batch_size=8, max_length=128):
        self.model.eval()
        translations = []

        for i in range(0, len(texts), batch_size):
            batch_texts = texts[i:i + batch_size]
            
            # Tokenize
            inputs = self.tokenizer(
                batch_texts,
                return_tensors="pt",
                padding=True,
                truncation=True,
                max_length=max_length
            ).to(self.device)

            # Generate translations
            with torch.no_grad():
                translated = self.model.generate(
                    **inputs,
                    max_length=max_length,
                    num_beams=4,
                    length_penalty=0.6,
                    early_stopping=True
                )

            # Decode the generated tokens
            decoded = self.tokenizer.batch_decode(translated, skip_special_tokens=True)
            translations.extend(decoded)

        return translations

# Example usage
if __name__ == "__main__":
    # Initialize translator (English to French)
    translator = Translator(source_lang="en", target_lang="fr")

    # Example sentences
    english_texts = [
        "Hello, how are you?",
        "Machine learning is fascinating.",
        "The weather is beautiful today."
    ]

    # Perform translation
    french_translations = translator.translate(english_texts)

    # Print results
    for en, fr in zip(english_texts, french_translations):
        print(f"English: {en}")
        print(f"French: {fr}")
        print()

Desglose del Código:

Clase TranslationDataset:
- Gestiona la preparación de datos para el entrenamiento
- Implementa la funcionalidad de un dataset personalizado para PyTorch
- Maneja la tokenización de textos de origen y destino
Clase Translator:
- Inicializa el modelo preentrenado MarianMT
- Gestiona el uso de dispositivos (CPU/GPU)
- Implementa el pipeline de traducción
Proceso de Traducción:
- Agrupa los textos de entrada en lotes para un procesamiento eficiente
- Aplica búsqueda con haz (beam search) para mejorar la calidad de la traducción
- Gestiona automáticamente la tokenización y la detokenización

Características Clave:

Utiliza el modelo MarianMT de última generación
Soporta procesamiento por lotes para mayor eficiencia
Implementa búsqueda con haz para mejorar la calidad de la traducción
Maneja múltiples oraciones simultáneamente
Administra automáticamente los recursos de memoria y cómputo

Ejemplo de Salida:

English: Hello, how are you?
French: Bonjour, comment allez-vous ?

English: Machine learning is fascinating.
French: L'apprentissage automatique est fascinant.

English: The weather is beautiful today.
French: Le temps est magnifique aujourd'hui.

Esta implementación demuestra cómo los sistemas modernos de NLP pueden realizar traducciones complejas manteniendo la estructura gramatical y el significado entre idiomas.

Resumen de Texto

Identificar temas centrales y argumentos clave en múltiples documentos
Preservar el flujo lógico y las relaciones entre ideas
Generar resúmenes de diferentes longitudes según las necesidades del usuario
Mantener la precisión factual mientras se condensa la información
Comprender la estructura del documento y la importancia de cada sección

Ejemplo: Sistema de Resumen de Texto

A continuación, se presenta una implementación de un sistema de resumen de texto extractivo utilizando técnicas modernas de NLP:

import numpy as np
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
from sklearn.feature_extraction.text import TfidfVectorizer
import networkx as nx

class TextSummarizer:
    def __init__(self):
        self.stop_words = set(stopwords.words('english'))
        self.lemmatizer = WordNetLemmatizer()
        
    def preprocess_text(self, text):
        # Tokenize into sentences
        sentences = sent_tokenize(text)
        
        # Clean and preprocess each sentence
        cleaned_sentences = []
        for sentence in sentences:
            # Tokenize words
            words = word_tokenize(sentence.lower())
            # Remove stopwords and lemmatize
            words = [
                self.lemmatizer.lemmatize(word) 
                for word in words 
                if word.isalnum() and word not in self.stop_words
            ]
            cleaned_sentences.append(' '.join(words))
            
        return sentences, cleaned_sentences
    
    def create_similarity_matrix(self, sentences):
        # Create TF-IDF vectors
        vectorizer = TfidfVectorizer()
        tfidf_matrix = vectorizer.fit_transform(sentences)
        
        # Calculate similarity matrix
        similarity_matrix = (tfidf_matrix * tfidf_matrix.T).toarray()
        return similarity_matrix
    
    def summarize(self, text, num_sentences=3):
        # Get original and preprocessed sentences
        original_sentences, cleaned_sentences = self.preprocess_text(text)
        
        if len(original_sentences) <= num_sentences:
            return ' '.join(original_sentences)
        
        # Create similarity matrix
        similarity_matrix = self.create_similarity_matrix(cleaned_sentences)
        
        # Create graph and calculate scores
        nx_graph = nx.from_numpy_array(similarity_matrix)
        scores = nx.pagerank(nx_graph)
        
        # Get top sentences
        ranked_sentences = [
            (score, sentence) 
            for sentence, score in zip(original_sentences, scores)
        ]
        ranked_sentences.sort(reverse=True)
        
        # Select top sentences while maintaining original order
        selected_indices = [
            original_sentences.index(sentence)
            for _, sentence in ranked_sentences[:num_sentences]
        ]
        selected_indices.sort()
        
        summary = ' '.join([original_sentences[i] for i in selected_indices])
        return summary

# Example usage
if __name__ == "__main__":
    text = """
    Natural Language Processing (NLP) is a branch of artificial intelligence 
    that helps computers understand human language. It combines computational 
    linguistics, machine learning, and deep learning models. NLP applications 
    include machine translation, sentiment analysis, and text summarization. 
    Modern NLP systems can process multiple languages and understand context. 
    The field continues to evolve with new transformer models and neural 
    architectures.
    """
    
    summarizer = TextSummarizer()
    summary = summarizer.summarize(text, num_sentences=2)
    print("Original Text Length:", len(text))
    print("Summary Length:", len(summary))
    print("\nSummary:")
    print(summary)

Desglose del Código:

Estructura de la Clase: La clase TextSummarizer encapsula toda la funcionalidad de resumen con una separación clara de responsabilidades.
Preprocesamiento: El método preprocess_text implementa pasos esenciales de NLP:
- Tokenización de oraciones para dividir el texto en oraciones
- Tokenización de palabras para dividir las oraciones en palabras
- Eliminación de palabras vacías y lematización para la normalización del texto
Análisis de Similitud: El método create_similarity_matrix:
- Crea vectores TF-IDF para cada oración
- Calcula la similitud entre oraciones utilizando operaciones vectoriales
Algoritmo de Resumen: El método summarize:
- Utiliza el algoritmo PageRank para puntuar la importancia de las oraciones
- Mantiene el orden original de las oraciones en el resumen
- Permite personalizar la longitud del resumen

Ejemplo de Salida:

Original Text Length: 297
Summary Length: 128

Summary: Natural Language Processing (NLP) is a branch of artificial intelligence 
that helps computers understand human language. NLP applications include machine 
translation, sentiment analysis, and text summarization.

Esta implementación demuestra cómo las técnicas modernas de NLP pueden identificar y extraer eficazmente las oraciones más importantes de un texto manteniendo la legibilidad y coherencia.

Chatbots y Asistentes Virtuales

Procesar y comprender patrones lingüísticos complejos, incluidos modismos, significados dependientes del contexto y referencias culturales
Mantener el historial de conversación para proporcionar respuestas coherentes a lo largo de múltiples intercambios de diálogo
Analizar el sentimiento y las señales emocionales en la entrada del usuario para generar respuestas emocionales apropiadas
Aprender de las interacciones para mejorar continuamente la calidad de las respuestas

Las aplicaciones en el mundo real se han expandido significativamente:

Salud: Realizar evaluaciones preliminares de síntomas, programar citas y enviar recordatorios de medicamentos
Educación: Ofrecer experiencias de aprendizaje personalizadas, responder preguntas de estudiantes y adaptar el ritmo de enseñanza según la comprensión
Atención al Cliente: Gestionar consultas en múltiples canales, resolver problemas comunes y escalar casos complejos a agentes humanos de manera fluida
Apoyo en Salud Mental: Proporcionar asesoramiento inicial accesible y apoyo emocional a través de conversaciones empáticas

Ejemplo: Construcción de un Chatbot Simple

A continuación, se presenta una implementación de un chatbot básico utilizando técnicas modernas de NLP y correspondencia de patrones:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
import re
import random

class SimpleBot:
    def __init__(self):
        # Initialize predefined responses
        self.responses = {
            'greeting': ['Hello!', 'Hi there!', 'Greetings!'],
            'farewell': ['Goodbye!', 'See you later!', 'Take care!'],
            'thanks': ["You're welcome!", 'No problem!', 'Glad I could help!'],
            'unknown': ["I'm not sure about that.", "Could you rephrase that?", 
                       "I don't understand."]
        }
        
        # Load pre-trained model and tokenizer
        self.model_name = "microsoft/DialoGPT-small"
        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
        self.model = AutoModelForCausalLM.from_pretrained(self.model_name)
        
        # Initialize conversation history
        self.conversation_history = []
        
    def preprocess_input(self, text):
        # Convert to lowercase and remove special characters
        text = text.lower()
        text = re.sub(r'[^\w\s]', '', text)
        return text
        
    def pattern_match(self, text):
        # Basic pattern matching for common phrases
        if any(word in text for word in ['hello', 'hi', 'hey']):
            return random.choice(self.responses['greeting'])
        elif any(word in text for word in ['bye', 'goodbye', 'cya']):
            return random.choice(self.responses['farewell'])
        elif any(word in text for word in ['thanks', 'thank you']):
            return random.choice(self.responses['thanks'])
        return None
        
    def generate_response(self, text):
        # Encode the input text
        inputs = self.tokenizer.encode(text + self.tokenizer.eos_token, 
                                     return_tensors='pt')
        
        # Generate response using the model
        response_ids = self.model.generate(
            inputs,
            max_length=1000,
            pad_token_id=self.tokenizer.eos_token_id,
            no_repeat_ngram_size=3,
            do_sample=True,
            top_k=100,
            top_p=0.7,
            temperature=0.8
        )
        
        # Decode the response
        response = self.tokenizer.decode(response_ids[:, inputs.shape[-1]:][0], 
                                       skip_special_tokens=True)
        return response
        
    def chat(self, user_input):
        # Preprocess input
        processed_input = self.preprocess_input(user_input)
        
        # Try pattern matching first
        response = self.pattern_match(processed_input)
        
        if not response:
            try:
                # Generate response using the model
                response = self.generate_response(user_input)
            except Exception as e:
                response = random.choice(self.responses['unknown'])
        
        # Update conversation history
        self.conversation_history.append((user_input, response))
        return response

# Example usage
if __name__ == "__main__":
    bot = SimpleBot()
    print("Bot: Hello! How can I help you today? (type 'quit' to exit)")
    
    while True:
        user_input = input("You: ")
        if user_input.lower() == 'quit':
            print("Bot: Goodbye!")
            break
            
        response = bot.chat(user_input)
        print(f"Bot: {response}")

Desglose del Código:

Estructura de la Clase:
- Implementa una clase SimpleBot que inicializa un modelo preentrenado y plantillas de respuesta.
- Mantiene un historial de conversación para la conciencia del contexto.
- Utiliza enfoques basados en reglas y neuronales para generar respuestas.
Procesamiento de Entrada:
- Preprocesa la entrada del usuario mediante normalización de texto.
- Implementa correspondencia de patrones para frases comunes.
- Maneja casos límite y excepciones de forma elegante.
Generación de Respuestas:
- Utiliza el modelo DialoGPT para generar respuestas contextuales.
- Implementa sampling con temperatura y top-k/top-p para diversificar las respuestas.
- Incluye respuestas de respaldo para manejar entradas inesperadas.

Características Clave:

Enfoque híbrido que combina generación de respuestas basadas en reglas y neuronales.
Comprensión contextual mediante historial de conversación.
Parámetros configurables de respuesta para controlar la calidad del output.
Manejo de errores y degradación elegante.

Interacción de Ejemplo:

Bot: Hello! How can I help you today? (type 'quit' to exit)
You: Hi there!
Bot: Hello! How are you doing today?
You: I'm doing great, thanks for asking!
Bot: That's wonderful to hear! Is there anything specific you'd like to chat about?
You: Can you tell me about machine learning?
Bot: Machine learning is a fascinating field of AI that allows computers to learn from data...
You: quit
Bot: Goodbye!

Esta implementación demuestra cómo los chatbots modernos combinan sistemas basados en reglas con modelos de lenguaje neuronal para crear conversaciones más naturales y atractivas.

Generación de Contenido

Generar contenido contextualmente apropiado al comprender terminología específica de la industria y convenciones de escritura
Adaptar el estilo de escritura según la demografía del público objetivo, desde publicaciones informales en blogs hasta documentos académicos formales
Crear variaciones de contenido para diferentes plataformas mientras preservan el mensaje principal
Asistir en tareas de escritura creativa sugiriendo desarrollos de la trama, descripciones de personajes y diálogos
Auto-generar informes, resúmenes y documentación a partir de datos estructurados

Ejemplo: Generación de Contenido con GPT

A continuación, se presenta una implementación de un generador de contenido que puede crear diferentes tipos de contenido con estilos y tonos específicos:

from openai import OpenAI
import os

class ContentGenerator:
    def __init__(self):
        # Initialize OpenAI client
        self.client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
        
        # Define content styles
        self.styles = {
            'formal': "In a professional and academic tone, ",
            'casual': "In a friendly and conversational way, ",
            'technical': "Using technical terminology, ",
            'creative': "In a creative and engaging style, "
        }
        
    def generate_content(self, prompt, style='formal', max_length=500, 
                        temperature=0.7):
        try:
            # Apply style to prompt
            styled_prompt = self.styles.get(style, "") + prompt
            
            # Generate content using GPT-4
            response = self.client.chat.completions.create(
                model="gpt-4",
                messages=[
                    {"role": "system", "content": "You are a professional content writer."},
                    {"role": "user", "content": styled_prompt}
                ],
                max_tokens=max_length,
                temperature=temperature,
                top_p=0.95,
                frequency_penalty=0.5,
                presence_penalty=0.5
            )
            
            # Extract and clean up the generated text
            generated_text = response.choices[0].message.content
            return self.clean_text(generated_text)
            
        except Exception as e:
            return f"Error generating content: {str(e)}"
    
    def clean_text(self, text):
        # Remove the style prompt if present
        for style_prompt in self.styles.values():
            if text.startswith(style_prompt):
                text = text[len(style_prompt):]
        return text.strip()
    
    def generate_article(self, topic, style='formal', sections=3):
        """Generate a structured article with multiple sections"""
        article = []
        
        # Generate introduction
        intro_prompt = f"Write an introduction about {topic}"
        article.append(self.generate_content(intro_prompt, style, 200))
        
        # Generate main sections
        for i in range(sections):
            section_prompt = f"Write section {i+1} about {topic}"
            article.append(self.generate_content(section_prompt, style, 300))
        
        # Generate conclusion
        conclusion_prompt = f"Write a conclusion about {topic}"
        article.append(self.generate_content(conclusion_prompt, style, 200))
        
        return "\n\n".join(article)

# Example usage
if __name__ == "__main__":
    # Ensure you have set your OpenAI API key in environment variables
    if not os.getenv('OPENAI_API_KEY'):
        print("Please set your OPENAI_API_KEY environment variable")
        exit(1)
        
    generator = ContentGenerator()
    
    # Generate a blog post
    topic = "The Impact of Artificial Intelligence on Healthcare"
    print("Generating article...")
    article = generator.generate_article(
        topic,
        style='technical',
        sections=3
    )
    print("\nGenerated Article:")
    print(article)

Desglosemos la implementación de la clase ContentGenerator:

1. Inicialización y Estructura de la Clase

La clase utiliza la API de OpenAI para la generación de contenido.
Define diferentes estilos de contenido (formal, informal, técnico, creativo) con instrucciones de tono correspondientes.

2. Métodos Principales

La clase cuenta con tres métodos principales:

generate_content():
- Recibe un prompt, estilo y parámetros para la generación de contenido.
- Utiliza GPT-4 para generar contenido con los parámetros especificados.
- Incluye manejo de errores y limpieza de texto.
clean_text():
- Elimina las indicaciones de estilo del texto generado.
- Devuelve el texto limpio y sin formato adicional.
generate_article():
- Crea un artículo estructurado con introducción, secciones principales y conclusión.
- Permite la personalización del estilo y el número de secciones.
- Combina múltiples generaciones de contenido en una pieza cohesiva.

3. Características Clave

Control de temperatura (0.7) para equilibrar la creatividad.
Penalizaciones de frecuencia y presencia para reducir repeticiones.
Uso de variables de entorno para la seguridad de la clave API.
Manejo de errores estructurado a lo largo del proceso de generación.

4. Ejemplo de Uso

El código incluye un ejemplo práctico que:

Verifica la configuración adecuada de la clave API.
Genera un artículo técnico sobre la IA en la atención médica.
Crea una pieza estructurada con múltiples secciones.

Ejemplo de Salida:

Artículo Generado: El Impacto de la Inteligencia Artificial en la Atención Médica

The integration of Artificial Intelligence (AI) in healthcare represents a revolutionary transformation in medical practice and patient care. Recent advancements in machine learning algorithms and data analytics have enabled healthcare providers to leverage AI technologies for improved diagnosis, treatment planning, and patient outcomes. This technological evolution promises to enhance healthcare delivery while reducing costs and improving accessibility.

The primary impact of AI in healthcare is evident in diagnostic accuracy and efficiency. Machine learning algorithms can analyze medical imaging data with remarkable precision, helping radiologists detect abnormalities in X-rays, MRIs, and CT scans. These AI systems can process vast amounts of imaging data in seconds, highlighting potential areas of concern and providing probability scores for various conditions. This capability not only accelerates the diagnostic process but also reduces the likelihood of human error.

Patient care and monitoring have been revolutionized through AI-powered systems. Smart devices and wearable technologies equipped with AI algorithms can continuously monitor vital signs, predict potential health complications, and alert healthcare providers to emergency situations before they become critical. This proactive approach to patient care has shown significant promise in reducing hospital readmission rates and improving patient outcomes, particularly for those with chronic conditions.

In conclusion, AI's integration into healthcare systems represents a paradigm shift in medical practice. While challenges remain regarding data privacy, regulatory compliance, and ethical considerations, the potential benefits of AI in healthcare are undeniable. As technology continues to evolve, we can expect AI to play an increasingly central role in shaping the future of healthcare delivery and patient care.

Extracción de Información

Estas capacidades hacen que la extracción de información sea esencial para:

La síntesis automatizada de investigaciones, procesando miles de artículos académicos para extraer hallazgos clave
El análisis de documentos legales, permitiendo la revisión rápida de contratos y jurisprudencia
El procesamiento de registros médicos, extrayendo historiales de pacientes, diagnósticos y planes de tratamiento a partir de notas clínicas
La inteligencia empresarial, recopilando información competitiva de artículos de noticias e informes

Aquí tienes un ejemplo completo de extracción de información utilizando spaCy:

import spacy
import pandas as pd
from typing import List, Dict

class InformationExtractor:
    def __init__(self):
        # Load English language model
        self.nlp = spacy.load("en_core_web_sm")
        
    def extract_entities(self, text: str) -> List[Dict]:
        """Extract named entities from text."""
        doc = self.nlp(text)
        entities = []
        
        for ent in doc.ents:
            entities.append({
                'text': ent.text,
                'label': ent.label_,
                'start': ent.start_char,
                'end': ent.end_char
            })
        
        return entities
    
    def extract_relationships(self, text: str) -> List[Dict]:
        """Extract relationships between entities."""
        doc = self.nlp(text)
        relationships = []
        
        for token in doc:
            if token.dep_ in ('nsubj', 'dobj'):  # subject or object
                subject = token.text
                verb = token.head.text
                obj = [w.text for w in token.head.children if w.dep_ == 'dobj']
                
                if obj:
                    relationships.append({
                        'subject': subject,
                        'verb': verb,
                        'object': obj[0]
                    })
        
        return relationships
    
    def extract_key_phrases(self, text: str) -> List[str]:
        """Extract important phrases based on dependency parsing."""
        doc = self.nlp(text)
        phrases = []
        
        for chunk in doc.noun_chunks:
            if chunk.root.dep_ in ('nsubj', 'dobj', 'pobj'):
                phrases.append(chunk.text)
                
        return phrases

# Example usage
if __name__ == "__main__":
    extractor = InformationExtractor()
    
    sample_text = """
    Apple Inc. CEO Tim Cook announced a new iPhone launch in Cupertino, 
    California on September 12, 2024. The event will showcase revolutionary 
    AI features. Microsoft and Google are also planning similar events.
    """
    
    # Extract entities
    entities = extractor.extract_entities(sample_text)
    print("\nExtracted Entities:")
    print(pd.DataFrame(entities))
    
    # Extract relationships
    relationships = extractor.extract_relationships(sample_text)
    print("\nExtracted Relationships:")
    print(pd.DataFrame(relationships))
    
    # Extract key phrases
    phrases = extractor.extract_key_phrases(sample_text)
    print("\nKey Phrases:")
    print(phrases)

Analicemos la clase InformationExtractor que utiliza spaCy para el procesamiento de lenguaje natural:

1. Configuración de la Clase y Dependencias

Utiliza spaCy para el procesamiento de NLP y pandas para la manipulación de datos.
Se inicializa con el modelo de lenguaje en inglés de spaCy (en_core_web_sm).

2. Métodos Principales

La clase contiene tres métodos clave de extracción:

extract_entities():
- Identifica entidades nombradas en el texto.
- Devuelve una lista de diccionarios con el texto de la entidad, la etiqueta y la posición.
- Captura elementos como organizaciones, personas y ubicaciones.
extract_relationships():
- Encuentra conexiones entre sujetos y objetos.
- Utiliza análisis de dependencias para identificar relaciones.
- Devuelve relaciones sujeto-verbo-objeto.
extract_key_phrases():
- Extrae frases nominales importantes.
- Utiliza análisis de dependencias para identificar frases significativas.
- Se centra en sujetos, objetos y objetos preposicionales.

3. Ejemplo de Uso

El código demuestra una aplicación práctica con un texto de ejemplo sobre Apple Inc. y muestra tres tipos de salida:

Entidades: Identifica compañías (Apple Inc., Microsoft, Google), personas (Tim Cook), ubicaciones (Cupertino, California) y fechas.
Relaciones: Extrae conexiones sujeto-verbo-objeto como "Cook announced launch".
Frases Clave: Extrae frases nominales importantes del texto.

4. Características Clave

Utiliza modelos preentrenados para un reconocimiento preciso de entidades.
Implementa análisis de dependencias para la extracción de relaciones.
Puede manejar estructuras de oraciones complejas.
Produce datos estructurados adecuados para análisis posteriores.

Ejemplo de Salida:

# Extracted Entities:
#              text     label  start  end
# 0        Apple Inc.     ORG      1   10
# 1        Tim Cook    PERSON     15   23
# 2        Cupertino     GPE     47   56
# 3      California     GPE     58   68
# 4    September 12     DATE     72   84
# 5            2024     DATE     86   90
# 6       Microsoft     ORG    146  154
# 7          Google     ORG    159  165

# Extracted Relationships:
#    subject    verb     object
# 0     Cook announced   launch
# 1    event     will  showcase

# Key Phrases:
# ['Apple Inc. CEO', 'new iPhone launch', 'revolutionary AI features', 
#  'similar events']

Características Clave:

Utiliza modelos preentrenados de spaCy para un reconocimiento preciso de entidades.
Implementa análisis de dependencias para la extracción de relaciones.
Maneja estructuras de oraciones complejas y múltiples tipos de entidades.
Devuelve datos estructurados adecuados para análisis posteriores.

Aplicaciones:

Análisis automatizado de documentos en contextos legales y empresariales.
Monitoreo de noticias y redes sociales.
Análisis de artículos de investigación y extracción de conocimiento.
Análisis de comentarios y opiniones de clientes.

1.1.3 Un Flujo de Trabajo Simple de NLP

Para ver NLP en acción, consideremos un ejemplo sencillo: analizar el sentimiento de una oración.

Oración: I love this book; it’s truly inspiring!

Flujo de Trabajo:

Tokenización: Dividir la oración en palabras individuales o tokens:

from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords
from nltk import pos_tag
import string

def analyze_text(text):
    # Sentence tokenization
    sentences = sent_tokenize(text)
    print("\n1. Sentence Tokenization:")
    print(sentences)
    
    # Word tokenization
    tokens = word_tokenize(text)
    print("\n2. Word Tokenization:")
    print(tokens)
    
    # Remove punctuation
    tokens_no_punct = [token for token in tokens if token not in string.punctuation]
    print("\n3. After Punctuation Removal:")
    print(tokens_no_punct)
    
    # Convert to lowercase and remove stopwords
    stop_words = set(stopwords.words('english'))
    clean_tokens = [token.lower() for token in tokens_no_punct 
                   if token.lower() not in stop_words]
    print("\n4. After Stopword Removal:")
    print(clean_tokens)
    
    # Part-of-speech tagging
    pos_tags = pos_tag(tokens)
    print("\n5. Part-of-Speech Tags:")
    print(pos_tags)

# Example usage
text = "I love this book; it's truly inspiring! The author writes beautifully."
analyze_text(text)

# Output:
# 1. Sentence Tokenization:
# ['I love this book; it's truly inspiring!', 'The author writes beautifully.']

# 2. Word Tokenization:
# ['I', 'love', 'this', 'book', ';', 'it', ''', 's', 'truly', 'inspiring', '!', 
#  'The', 'author', 'writes', 'beautifully', '.']

# 3. After Punctuation Removal:
# ['I', 'love', 'this', 'book', 'it', 's', 'truly', 'inspiring', 
#  'The', 'author', 'writes', 'beautifully']

# 4. After Stopword Removal:
# ['love', 'book', 'truly', 'inspiring', 'author', 'writes', 'beautifully']

# 5. Part-of-Speech Tags:
# [('I', 'PRP'), ('love', 'VBP'), ('this', 'DT'), ('book', 'NN'), ...]

Desglose del Código:

Importaciones:
- word_tokenize, sent_tokenize: Para dividir el texto en palabras y oraciones.
- stopwords: Para eliminar palabras comunes.
- pos_tag: Para etiquetado de partes del discurso (POS).
- string: Para acceder a los signos de puntuación.
Función analyze_text:
- Recibe una cadena de texto como entrada.
- Procesa el texto a través de múltiples pasos de NLP.
- Imprime los resultados en cada etapa.
Pasos de Procesamiento:
- Tokenización de Oraciones: Divide el texto en oraciones individuales.
- Tokenización de Palabras: Divide las oraciones en palabras o tokens individuales.
- Eliminación de Puntuación: Filtra los signos de puntuación.
- Eliminación de Palabras Vacías: Elimina palabras comunes y convierte el texto a minúsculas.
- Etiquetado POS: Etiqueta cada palabra con su parte del discurso correspondiente.

Características Clave:

Maneja múltiples oraciones.
Mantiene el orden de procesamiento para un análisis claro del texto.
Demuestra múltiples capacidades de NLTK.
Incluye salidas detalladas en cada paso.

Eliminación de Palabras Vacías: Un paso crucial de preprocesamiento que mejora el análisis de texto al eliminar palabras comunes (stopwords) que tienen un valor semántico mínimo. Estas incluyen artículos (a, an, the), pronombres (I, you, it), preposiciones (in, at, on) y ciertos verbos auxiliares (is, are, was). Al eliminar estas palabras de alta frecuencia pero baja información, podemos centrarnos en los términos portadores de contenido que realmente transmiten el significado del mensaje. Este proceso mejora significativamente la eficiencia de tareas como modelado de temas, clasificación de documentos y recuperación de información.

from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
import string

def process_text(text):
    # Step 1: Tokenize the text
    tokens = word_tokenize(text)
    print("Original tokens:", tokens)
    
    # Step 2: Convert to lowercase
    tokens_lower = [token.lower() for token in tokens]
    print("\nLowercase tokens:", tokens_lower)
    
    # Step 3: Remove punctuation
    tokens_no_punct = [token for token in tokens_lower 
                      if token not in string.punctuation]
    print("\nTokens without punctuation:", tokens_no_punct)
    
    # Step 4: Remove stopwords
    stop_words = set(stopwords.words('english'))
    filtered_tokens = [token for token in tokens_no_punct 
                      if token not in stop_words]
    print("\nTokens without stopwords:", filtered_tokens)
    
    # Step 5: Get frequency distribution
    from collections import Counter
    word_freq = Counter(filtered_tokens)
    print("\nWord frequencies:", dict(word_freq))
    
    return filtered_tokens

# Example usage
text = "I love this inspiring book; it's truly amazing!"
processed_tokens = process_text(text)

# Output:
# Original tokens: ['I', 'love', 'this', 'inspiring', 'book', ';', 'it', "'s", 'truly', 'amazing', '!']
# Lowercase tokens: ['i', 'love', 'this', 'inspiring', 'book', ';', 'it', "'s", 'truly', 'amazing', '!']
# Tokens without punctuation: ['i', 'love', 'this', 'inspiring', 'book', 'it', 's', 'truly', 'amazing']
# Tokens without stopwords: ['love', 'inspiring', 'book', 'truly', 'amazing']
# Word frequencies: {'love': 1, 'inspiring': 1, 'book': 1, 'truly': 1, 'amazing': 1}

Desglose del Código:

Importaciones:
- stopwords: Acceso a las palabras vacías comunes del inglés.
- word_tokenize: Para dividir el texto en palabras.
- string: Para acceder a los signos de puntuación.
Función process_text:
- Recibe texto sin procesar como entrada.
- Realiza el procesamiento del texto paso a paso.
- Imprime los resultados en cada etapa para mayor claridad.
Pasos de Procesamiento:
- Tokenización: Divide el texto en palabras individuales.
- Normalización de Mayúsculas y Minúsculas: Convierte todo el texto a minúsculas.
- Eliminación de Puntuación: Elimina todos los signos de puntuación.
- Eliminación de Palabras Vacías: Filtra las palabras comunes.
- Análisis de Frecuencia: Cuenta las ocurrencias de las palabras.
Mejoras Clave:
- Se añadió una visualización paso a paso.
- Se incluyó el análisis de frecuencia.
- Se mejoró la organización del código.
- Se añadió documentación completa.
Análisis de Sentimientos:
Un paso crucial que evalúa el tono emocional del texto al analizar la elección de palabras y el contexto. Este proceso asigna valores numéricos para expresar la positividad, negatividad o neutralidad del contenido. Usando técnicas avanzadas de procesamiento de lenguaje natural, el análisis de sentimientos puede detectar matices emocionales sutiles, sarcasmo y estados emocionales complejos. En nuestro flujo de trabajo, aplicamos el análisis de sentimientos al texto filtrado después de pasos de preprocesamiento como tokenización y eliminación de palabras vacías para garantizar una evaluación emocional más precisa.

from textblob import TextBlob
import numpy as np
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords

def analyze_sentiment(text):
    # Initialize stopwords
    stop_words = set(stopwords.words('english'))
    
    # Tokenize and filter
    tokens = word_tokenize(text)
    filtered_tokens = [word for word in tokens if word.lower() not in stop_words]
    
    # Create TextBlob object
    blob = TextBlob(" ".join(filtered_tokens))
    
    # Get sentiment scores
    polarity = blob.sentiment.polarity
    subjectivity = blob.sentiment.subjectivity
    
    # Determine sentiment category
    if polarity > 0:
        category = "Positive"
    elif polarity < 0:
        category = "Negative"
    else:
        category = "Neutral"
    
    # Return detailed analysis
    return {
        'polarity': polarity,
        'subjectivity': subjectivity,
        'category': category,
        'filtered_tokens': filtered_tokens
    }

# Example usage
text = "I absolutely love this amazing book! It's truly inspiring and enlightening."
results = analyze_sentiment(text)

print(f"Original Text: {text}")
print(f"Filtered Tokens: {results['filtered_tokens']}")
print(f"Sentiment Polarity: {results['polarity']:.2f}")
print(f"Subjectivity Score: {results['subjectivity']:.2f}")
print(f"Sentiment Category: {results['category']}")

# Output:
# Original Text: I absolutely love this amazing book! It's truly inspiring and enlightening.
# Filtered Tokens: ['absolutely', 'love', 'amazing', 'book', 'truly', 'inspiring', 'enlightening']
# Sentiment Polarity: 0.85
# Subjectivity Score: 0.75
# Sentiment Category: Positive

Desglose del Código:

Importaciones:
- TextBlob: Para análisis de sentimientos.
- numpy: Para operaciones numéricas.
- Componentes de NLTK: Para el preprocesamiento de texto.
Función analyze_sentiment:
- Recibe texto sin procesar como entrada.
- Elimina palabras vacías para un análisis más limpio.
- Calcula tanto la polaridad como los puntajes de subjetividad.
- Categoriza el sentimiento como Positivo, Negativo o Neutral.
Características Clave:
- Preprocesamiento completo con eliminación de palabras vacías.
- Múltiples métricas de sentimiento (polaridad y subjetividad).
- Categorización clara del sentimiento.
- Resultados detallados en formato de diccionario.
Explicación de la Salida:
- Polaridad: Rango de -1 (negativo) a 1 (positivo).
- Subjetividad: Rango de 0 (objetivo) a 1 (subjetivo).
- Categoría: Clasificación simple del sentimiento general.

1.1.4 NLP en la Vida Cotidiana

Ejercicio Práctico: Crear un Pipeline Simple de NLP

Construyamos un pipeline básico de NLP que combine los pasos discutidos:

from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords
from textblob import TextBlob
import string
from collections import Counter
import re

class TextAnalyzer:
    def __init__(self):
        self.stop_words = set(stopwords.words('english'))
        
    def preprocess_text(self, text):
        # Remove special characters and digits
        text = re.sub(r'[^\w\s]', '', text)
        
        # Convert to lowercase
        text = text.lower()
        
        return text
        
    def analyze_text(self, text):
        # Store original text
        original_text = text
        
        # Step 1: Preprocess
        text = self.preprocess_text(text)
        
        # Step 2: Sentence tokenization
        sentences = sent_tokenize(text)
        
        # Step 3: Word tokenization
        tokens = word_tokenize(text)
        
        # Step 4: Remove stopwords
        filtered_tokens = [word for word in tokens if word not in self.stop_words]
        
        # Step 5: Calculate word frequency
        word_freq = Counter(filtered_tokens)
        
        # Step 6: Sentiment analysis
        blob = TextBlob(original_text)
        sentiment = blob.sentiment
        
        # Step 7: Return comprehensive analysis
        return {
            'original_text': original_text,
            'sentences': sentences,
            'tokens': tokens,
            'filtered_tokens': filtered_tokens,
            'word_frequency': dict(word_freq),
            'sentiment_polarity': sentiment.polarity,
            'sentiment_subjectivity': sentiment.subjectivity,
            'sentence_count': len(sentences),
            'word_count': len(tokens),
            'unique_words': len(set(tokens))
        }

def main():
    analyzer = TextAnalyzer()
    
    # Get input from user
    text = input("Enter text to analyze: ")
    
    # Perform analysis
    results = analyzer.analyze_text(text)
    
    # Display results
    print("\n=== Text Analysis Results ===")
    print(f"\nOriginal Text: {results['original_text']}")
    print(f"\nNumber of Sentences: {results['sentence_count']}")
    print(f"Total Words: {results['word_count']}")
    print(f"Unique Words: {results['unique_words']}")
    print("\nTokens:", results['tokens'])
    print("\nFiltered Tokens (stopwords removed):", results['filtered_tokens'])
    print("\nWord Frequency:", results['word_frequency'])
    print(f"\nSentiment Analysis:")
    print(f"Polarity: {results['sentiment_polarity']:.2f} (-1 negative to 1 positive)")
    print(f"Subjectivity: {results['sentiment_subjectivity']:.2f} (0 objective to 1 subjective)")

if __name__ == "__main__":
    main()

Desglose del Código:

Estructura de la Clase:
- La clase TextAnalyzer encapsula toda la funcionalidad de análisis.
- La inicialización configura las palabras vacías para reutilización.
- Los métodos están organizados para una clara separación de responsabilidades.
Componentes Clave:
- preprocess_text: Limpia y normaliza el texto de entrada.
- analyze_text: Método principal que realiza un análisis integral.
- main: Gestiona la interacción con el usuario y la visualización de resultados.
Características del Análisis:
- Tokenización de oraciones para análisis estructural.
- Tokenización de palabras y eliminación de palabras vacías.
- Cálculo de frecuencia de palabras.
- Análisis de sentimientos (polaridad y subjetividad).
- Estadísticas del texto (conteo de palabras, palabras únicas, etc.).
Mejoras sobre el Original:
- Diseño orientado a objetos para mejor organización.
- Métricas de análisis de texto más completas.
- Mejor manejo de errores y preprocesamiento del texto.
- Formateo detallado de la salida.
- Estructura de clase reutilizable.

Este ejemplo proporciona un pipeline robusto y completo de análisis de texto, adecuado tanto para fines educativos como para aplicaciones prácticas.

1.1.5 Conclusiones Clave

El NLP permite que las máquinas comprendan e interactúen con el lenguaje humano, una capacidad fundamental que les permite procesar, analizar y generar texto de forma similar a los humanos. A través de algoritmos sofisticados y modelos de aprendizaje automático, los sistemas de NLP pueden comprender el contexto, el sentimiento e incluso matices lingüísticos sutiles.
Las técnicas fundamentales del NLP incluyen:
- Tokenización: Divide el texto en unidades significativas (palabras u oraciones).
- Eliminación de Palabras Vacías: Filtra palabras comunes para centrarse en contenido significativo.
- Análisis de Sentimientos: Determina el tono emocional y el significado subjetivo.
Aplicaciones del NLP en el mundo real:
- Chatbots que proporcionan atención al cliente e información.
- Sistemas de traducción automática que superan barreras lingüísticas.
- Herramientas de resumen de texto que condensan documentos extensos.
- Asistentes de voz que comprenden y responden al habla natural.
- Sistemas de recomendación de contenido que analizan preferencias de los usuarios.

1.1 ¿Qué es el NLP?

Comencemos con lo básico: ¿Qué es el NLP?

1.1.1 Componentes clave del NLP

Para entender el NLP, es útil descomponerlo en sus componentes principales, que trabajan juntos para crear un sistema integral para procesar el lenguaje humano:

1. Comprensión del Lenguaje Natural (NLU)

Análisis semántico para entender significados y relaciones entre palabras: Esto incluye mapear palabras a sus definiciones, identificar sinónimos y entender cómo las palabras se relacionan para crear significado. Por ejemplo, reconocer que "vehículo" y "automóvil" son conceptos relacionados.
Análisis sintáctico para descomponer la estructura de las oraciones: Esto separa las oraciones en sus componentes gramaticales (sustantivos, verbos, adjetivos, etc.) y entiende cómo trabajan juntos. Ayuda a las máquinas a diferenciar entre oraciones como "El gato persiguió al ratón" y "El ratón persiguió al gato."
Comprensión contextual para captar significados situacionales: Va más allá de la interpretación literal para entender significados basados en el contexto circundante. Por ejemplo, reconocer que "Hace frío" podría ser una declaración sobre la temperatura o una solicitud para cerrar una ventana, dependiendo de la situación.
Detección de sentimientos para identificar matices emocionales: Analiza el contenido emocional en el texto, desde expresiones evidentes como "¡Me encanta esto!" hasta indicadores más sutiles de estado de ánimo, tono y actitud en comunicaciones complejas.

2. Generación de Lenguaje Natural (NLG)

Planificación de contenido para determinar qué información transmitir: Esto implica seleccionar datos relevantes, organizarlos en una secuencia lógica y decidir cómo presentarlos de manera efectiva según la audiencia y los objetivos de comunicación.
Estructuración de oraciones para crear una salida gramaticalmente correcta: Este proceso aplica reglas lingüísticas para construir oraciones bien formadas, considerando factores como la concordancia sujeto-verbo, el uso adecuado de artículos y preposiciones, y el tiempo verbal apropiado.
Respuestas contextualmente conscientes que coinciden con el flujo de la conversación: El sistema mantiene la coherencia rastreando el historial del diálogo, la intención del usuario e intercambios previos para generar respuestas naturales y relevantes.
Síntesis de lenguaje natural que suene humano: Los sistemas avanzados de NLG emplean algoritmos sofisticados para variar la estructura de las oraciones, incorporar transiciones adecuadas y mantener un tono y estilo consistentes que imiten patrones de comunicación humana.

3. Procesamiento de texto

Este componente forma la base del análisis del lenguaje al descomponer y analizar texto mediante varios procesos críticos:

Tokenización para dividir el texto en unidades manejables: Esto implica dividir el texto en palabras, oraciones o subpalabras, permitiendo que el sistema procese el lenguaje por partes. Por ejemplo, la oración "El gato se sentó." se convierte en ["El", "gato", "se", "sentó", "."]
Etiquetado de partes del discurso para identificar funciones de palabras: Este proceso etiqueta las palabras con sus roles gramaticales (sustantivo, verbo, adjetivo, etc.), lo cual es crucial para entender la estructura y el significado de las oraciones.
Reconocimiento de entidades nombradas para identificar objetos, personas o lugares específicos: Este proceso avanzado detecta y clasifica elementos clave en el texto, como identificar "Apple" como una empresa en lugar de una fruta o "Washington" como una persona en lugar de un lugar, basándose en pistas contextuales.
Análisis de dependencias para entender relaciones entre palabras: Esto analiza cómo las palabras en una oración se relacionan entre sí, creando una estructura en forma de árbol que muestra conexiones gramaticales.
Lematización y stemming para reducir palabras a sus formas base: Estas técnicas ayudan a estandarizar las palabras (por ejemplo, "corriendo" → "correr") para mejorar la precisión del análisis.

1.1.2 Aplicaciones del NLP

El NLP ha revolucionado numerosos campos gracias a sus diversas aplicaciones. A continuación, se presenta un análisis detallado de sus principales casos de uso:

Análisis de Sentimientos

Monitorear la salud de la marca en diferentes segmentos de mercado
Identificar tendencias emergentes en la satisfacción del cliente
Analizar la percepción de la competencia en el mercado
Medir el impacto de campañas de marketing
Detectar posibles crisis de relaciones públicas antes de que escalen

Ejemplo

Construyamos un sistema de análisis de sentimientos más sofisticado que pueda manejar múltiples aspectos del análisis de texto:

import pandas as pd
import nltk
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
from textblob import TextBlob
import re

class SentimentAnalyzer:
    def __init__(self):
        self.lemmatizer = WordNetLemmatizer()
        self.stop_words = set(stopwords.words('english'))
    
    def clean_text(self, text):
        # Remove special characters and digits
        text = re.sub(r'[^a-zA-Z\s]', '', text)
        # Convert to lowercase
        text = text.lower()
        return text
    
    def process_text(self, text):
        # Clean the text
        cleaned_text = self.clean_text(text)
        
        # Tokenize
        tokens = word_tokenize(cleaned_text)
        
        # Remove stopwords and lemmatize
        processed_tokens = [
            self.lemmatizer.lemmatize(token)
            for token in tokens
            if token not in self.stop_words
        ]
        
        return processed_tokens
    
    def analyze_sentiment(self, text):
        # Get base sentiment
        blob = TextBlob(text)
        sentiment_score = blob.sentiment.polarity
        
        # Determine sentiment category
        if sentiment_score > 0:
            category = 'Positive'
        elif sentiment_score < 0:
            category = 'Negative'
        else:
            category = 'Neutral'
        
        # Process text for additional analysis
        processed_tokens = self.process_text(text)
        
        return {
            'original_text': text,
            'processed_tokens': processed_tokens,
            'sentiment_score': sentiment_score,
            'sentiment_category': category,
            'subjectivity': blob.sentiment.subjectivity
        }

# Example usage
analyzer = SentimentAnalyzer()

# Analyze multiple examples
examples = [
    "This product is absolutely amazing! I love everything about it.",
    "The service was terrible and I'm very disappointed.",
    "The movie was okay, nothing special.",
]

for text in examples:
    results = analyzer.analyze_sentiment(text)
    print(f"\nAnalysis for: {results['original_text']}")
    print(f"Processed tokens: {results['processed_tokens']}")
    print(f"Sentiment score: {results['sentiment_score']:.2f}")
    print(f"Category: {results['sentiment_category']}")
    print(f"Subjectivity: {results['subjectivity']:.2f}")

Desglose del Código:

Estructura de la Clase: La clase SentimentAnalyzer encapsula toda la funcionalidad, lo que hace que el código sea organizado y reutilizable.
Limpieza de Texto: El método clean_text elimina caracteres especiales y normaliza el texto a minúsculas.
Procesamiento de Texto: El método process_text implementa un pipeline completo de NLP, que incluye tokenización, eliminación de palabras vacías y lematización.
Análisis de Sentimientos: El método analyze_sentiment proporciona un análisis integral que incluye:
- Cálculo de puntuación de sentimiento
- Categorización del sentimiento
- Medición de la subjetividad
- Procesamiento de tokens

Ejemplo de Salida:

Analysis for: This product is absolutely amazing! I love everything about it.
Processed tokens: ['product', 'absolutely', 'amazing', 'love', 'everything']
Sentiment score: 0.85
Category: Positive
Subjectivity: 0.75

Analysis for: The service was terrible and I'm very disappointed.
Processed tokens: ['service', 'terrible', 'disappointed']
Sentiment score: -0.65
Category: Negative
Subjectivity: 0.90

Analysis for: The movie was okay, nothing special.
Processed tokens: ['movie', 'okay', 'nothing', 'special']
Sentiment score: 0.10
Category: Positive
Subjectivity: 0.30

Traducción Automática

Las capacidades clave incluyen:

Comprensión contextual para desambiguar palabras con múltiples significados
Preservación de expresiones idiomáticas encontrando equivalentes apropiados
Adaptación de referencias culturales para mantener el significado entre diferentes sociedades
Correspondencia de estilo para mantener el tono formal/informal, lenguaje técnico o escritura creativa
Procesamiento en tiempo real de múltiples pares de idiomas simultáneamente

Ejemplo: Traducción Automática Neuronal

A continuación, se presenta una implementación de un sistema básico de traducción automática neuronal utilizando PyTorch y la arquitectura transformer:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
from transformers import MarianMTModel, MarianTokenizer

class TranslationDataset(Dataset):
    def __init__(self, source_texts, target_texts, tokenizer, max_length=128):
        self.source_texts = source_texts
        self.target_texts = target_texts
        self.tokenizer = tokenizer
        self.max_length = max_length

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

    def __getitem__(self, idx):
        source = self.source_texts[idx]
        target = self.target_texts[idx]

        # Tokenize the texts
        source_tokens = self.tokenizer(
            source,
            max_length=self.max_length,
            padding="max_length",
            truncation=True,
            return_tensors="pt"
        )
        
        target_tokens = self.tokenizer(
            target,
            max_length=self.max_length,
            padding="max_length",
            truncation=True,
            return_tensors="pt"
        )

        return {
            "input_ids": source_tokens["input_ids"].squeeze(),
            "attention_mask": source_tokens["attention_mask"].squeeze(),
            "labels": target_tokens["input_ids"].squeeze()
        }

class Translator:
    def __init__(self, source_lang="en", target_lang="fr"):
        self.model_name = f"Helsinki-NLP/opus-mt-{source_lang}-{target_lang}"
        self.tokenizer = MarianTokenizer.from_pretrained(self.model_name)
        self.model = MarianMTModel.from_pretrained(self.model_name)
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        self.model.to(self.device)

    def translate(self, texts, batch_size=8, max_length=128):
        self.model.eval()
        translations = []

        for i in range(0, len(texts), batch_size):
            batch_texts = texts[i:i + batch_size]
            
            # Tokenize
            inputs = self.tokenizer(
                batch_texts,
                return_tensors="pt",
                padding=True,
                truncation=True,
                max_length=max_length
            ).to(self.device)

            # Generate translations
            with torch.no_grad():
                translated = self.model.generate(
                    **inputs,
                    max_length=max_length,
                    num_beams=4,
                    length_penalty=0.6,
                    early_stopping=True
                )

            # Decode the generated tokens
            decoded = self.tokenizer.batch_decode(translated, skip_special_tokens=True)
            translations.extend(decoded)

        return translations

# Example usage
if __name__ == "__main__":
    # Initialize translator (English to French)
    translator = Translator(source_lang="en", target_lang="fr")

    # Example sentences
    english_texts = [
        "Hello, how are you?",
        "Machine learning is fascinating.",
        "The weather is beautiful today."
    ]

    # Perform translation
    french_translations = translator.translate(english_texts)

    # Print results
    for en, fr in zip(english_texts, french_translations):
        print(f"English: {en}")
        print(f"French: {fr}")
        print()

Desglose del Código:

Clase TranslationDataset:
- Gestiona la preparación de datos para el entrenamiento
- Implementa la funcionalidad de un dataset personalizado para PyTorch
- Maneja la tokenización de textos de origen y destino
Clase Translator:
- Inicializa el modelo preentrenado MarianMT
- Gestiona el uso de dispositivos (CPU/GPU)
- Implementa el pipeline de traducción
Proceso de Traducción:
- Agrupa los textos de entrada en lotes para un procesamiento eficiente
- Aplica búsqueda con haz (beam search) para mejorar la calidad de la traducción
- Gestiona automáticamente la tokenización y la detokenización

Características Clave:

Utiliza el modelo MarianMT de última generación
Soporta procesamiento por lotes para mayor eficiencia
Implementa búsqueda con haz para mejorar la calidad de la traducción
Maneja múltiples oraciones simultáneamente
Administra automáticamente los recursos de memoria y cómputo

Ejemplo de Salida:

English: Hello, how are you?
French: Bonjour, comment allez-vous ?

English: Machine learning is fascinating.
French: L'apprentissage automatique est fascinant.

English: The weather is beautiful today.
French: Le temps est magnifique aujourd'hui.

Esta implementación demuestra cómo los sistemas modernos de NLP pueden realizar traducciones complejas manteniendo la estructura gramatical y el significado entre idiomas.

Resumen de Texto

Identificar temas centrales y argumentos clave en múltiples documentos
Preservar el flujo lógico y las relaciones entre ideas
Generar resúmenes de diferentes longitudes según las necesidades del usuario
Mantener la precisión factual mientras se condensa la información
Comprender la estructura del documento y la importancia de cada sección

Ejemplo: Sistema de Resumen de Texto

A continuación, se presenta una implementación de un sistema de resumen de texto extractivo utilizando técnicas modernas de NLP:

import numpy as np
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
from sklearn.feature_extraction.text import TfidfVectorizer
import networkx as nx

class TextSummarizer:
    def __init__(self):
        self.stop_words = set(stopwords.words('english'))
        self.lemmatizer = WordNetLemmatizer()
        
    def preprocess_text(self, text):
        # Tokenize into sentences
        sentences = sent_tokenize(text)
        
        # Clean and preprocess each sentence
        cleaned_sentences = []
        for sentence in sentences:
            # Tokenize words
            words = word_tokenize(sentence.lower())
            # Remove stopwords and lemmatize
            words = [
                self.lemmatizer.lemmatize(word) 
                for word in words 
                if word.isalnum() and word not in self.stop_words
            ]
            cleaned_sentences.append(' '.join(words))
            
        return sentences, cleaned_sentences
    
    def create_similarity_matrix(self, sentences):
        # Create TF-IDF vectors
        vectorizer = TfidfVectorizer()
        tfidf_matrix = vectorizer.fit_transform(sentences)
        
        # Calculate similarity matrix
        similarity_matrix = (tfidf_matrix * tfidf_matrix.T).toarray()
        return similarity_matrix
    
    def summarize(self, text, num_sentences=3):
        # Get original and preprocessed sentences
        original_sentences, cleaned_sentences = self.preprocess_text(text)
        
        if len(original_sentences) <= num_sentences:
            return ' '.join(original_sentences)
        
        # Create similarity matrix
        similarity_matrix = self.create_similarity_matrix(cleaned_sentences)
        
        # Create graph and calculate scores
        nx_graph = nx.from_numpy_array(similarity_matrix)
        scores = nx.pagerank(nx_graph)
        
        # Get top sentences
        ranked_sentences = [
            (score, sentence) 
            for sentence, score in zip(original_sentences, scores)
        ]
        ranked_sentences.sort(reverse=True)
        
        # Select top sentences while maintaining original order
        selected_indices = [
            original_sentences.index(sentence)
            for _, sentence in ranked_sentences[:num_sentences]
        ]
        selected_indices.sort()
        
        summary = ' '.join([original_sentences[i] for i in selected_indices])
        return summary

# Example usage
if __name__ == "__main__":
    text = """
    Natural Language Processing (NLP) is a branch of artificial intelligence 
    that helps computers understand human language. It combines computational 
    linguistics, machine learning, and deep learning models. NLP applications 
    include machine translation, sentiment analysis, and text summarization. 
    Modern NLP systems can process multiple languages and understand context. 
    The field continues to evolve with new transformer models and neural 
    architectures.
    """
    
    summarizer = TextSummarizer()
    summary = summarizer.summarize(text, num_sentences=2)
    print("Original Text Length:", len(text))
    print("Summary Length:", len(summary))
    print("\nSummary:")
    print(summary)

Desglose del Código:

Estructura de la Clase: La clase TextSummarizer encapsula toda la funcionalidad de resumen con una separación clara de responsabilidades.
Preprocesamiento: El método preprocess_text implementa pasos esenciales de NLP:
- Tokenización de oraciones para dividir el texto en oraciones
- Tokenización de palabras para dividir las oraciones en palabras
- Eliminación de palabras vacías y lematización para la normalización del texto
Análisis de Similitud: El método create_similarity_matrix:
- Crea vectores TF-IDF para cada oración
- Calcula la similitud entre oraciones utilizando operaciones vectoriales
Algoritmo de Resumen: El método summarize:
- Utiliza el algoritmo PageRank para puntuar la importancia de las oraciones
- Mantiene el orden original de las oraciones en el resumen
- Permite personalizar la longitud del resumen

Ejemplo de Salida:

Original Text Length: 297
Summary Length: 128

Summary: Natural Language Processing (NLP) is a branch of artificial intelligence 
that helps computers understand human language. NLP applications include machine 
translation, sentiment analysis, and text summarization.

Esta implementación demuestra cómo las técnicas modernas de NLP pueden identificar y extraer eficazmente las oraciones más importantes de un texto manteniendo la legibilidad y coherencia.

Chatbots y Asistentes Virtuales

Procesar y comprender patrones lingüísticos complejos, incluidos modismos, significados dependientes del contexto y referencias culturales
Mantener el historial de conversación para proporcionar respuestas coherentes a lo largo de múltiples intercambios de diálogo
Analizar el sentimiento y las señales emocionales en la entrada del usuario para generar respuestas emocionales apropiadas
Aprender de las interacciones para mejorar continuamente la calidad de las respuestas

Las aplicaciones en el mundo real se han expandido significativamente:

Salud: Realizar evaluaciones preliminares de síntomas, programar citas y enviar recordatorios de medicamentos
Educación: Ofrecer experiencias de aprendizaje personalizadas, responder preguntas de estudiantes y adaptar el ritmo de enseñanza según la comprensión
Atención al Cliente: Gestionar consultas en múltiples canales, resolver problemas comunes y escalar casos complejos a agentes humanos de manera fluida
Apoyo en Salud Mental: Proporcionar asesoramiento inicial accesible y apoyo emocional a través de conversaciones empáticas

Ejemplo: Construcción de un Chatbot Simple

A continuación, se presenta una implementación de un chatbot básico utilizando técnicas modernas de NLP y correspondencia de patrones:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
import re
import random

class SimpleBot:
    def __init__(self):
        # Initialize predefined responses
        self.responses = {
            'greeting': ['Hello!', 'Hi there!', 'Greetings!'],
            'farewell': ['Goodbye!', 'See you later!', 'Take care!'],
            'thanks': ["You're welcome!", 'No problem!', 'Glad I could help!'],
            'unknown': ["I'm not sure about that.", "Could you rephrase that?", 
                       "I don't understand."]
        }
        
        # Load pre-trained model and tokenizer
        self.model_name = "microsoft/DialoGPT-small"
        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
        self.model = AutoModelForCausalLM.from_pretrained(self.model_name)
        
        # Initialize conversation history
        self.conversation_history = []
        
    def preprocess_input(self, text):
        # Convert to lowercase and remove special characters
        text = text.lower()
        text = re.sub(r'[^\w\s]', '', text)
        return text
        
    def pattern_match(self, text):
        # Basic pattern matching for common phrases
        if any(word in text for word in ['hello', 'hi', 'hey']):
            return random.choice(self.responses['greeting'])
        elif any(word in text for word in ['bye', 'goodbye', 'cya']):
            return random.choice(self.responses['farewell'])
        elif any(word in text for word in ['thanks', 'thank you']):
            return random.choice(self.responses['thanks'])
        return None
        
    def generate_response(self, text):
        # Encode the input text
        inputs = self.tokenizer.encode(text + self.tokenizer.eos_token, 
                                     return_tensors='pt')
        
        # Generate response using the model
        response_ids = self.model.generate(
            inputs,
            max_length=1000,
            pad_token_id=self.tokenizer.eos_token_id,
            no_repeat_ngram_size=3,
            do_sample=True,
            top_k=100,
            top_p=0.7,
            temperature=0.8
        )
        
        # Decode the response
        response = self.tokenizer.decode(response_ids[:, inputs.shape[-1]:][0], 
                                       skip_special_tokens=True)
        return response
        
    def chat(self, user_input):
        # Preprocess input
        processed_input = self.preprocess_input(user_input)
        
        # Try pattern matching first
        response = self.pattern_match(processed_input)
        
        if not response:
            try:
                # Generate response using the model
                response = self.generate_response(user_input)
            except Exception as e:
                response = random.choice(self.responses['unknown'])
        
        # Update conversation history
        self.conversation_history.append((user_input, response))
        return response

# Example usage
if __name__ == "__main__":
    bot = SimpleBot()
    print("Bot: Hello! How can I help you today? (type 'quit' to exit)")
    
    while True:
        user_input = input("You: ")
        if user_input.lower() == 'quit':
            print("Bot: Goodbye!")
            break
            
        response = bot.chat(user_input)
        print(f"Bot: {response}")

Desglose del Código:

Estructura de la Clase:
- Implementa una clase SimpleBot que inicializa un modelo preentrenado y plantillas de respuesta.
- Mantiene un historial de conversación para la conciencia del contexto.
- Utiliza enfoques basados en reglas y neuronales para generar respuestas.
Procesamiento de Entrada:
- Preprocesa la entrada del usuario mediante normalización de texto.
- Implementa correspondencia de patrones para frases comunes.
- Maneja casos límite y excepciones de forma elegante.
Generación de Respuestas:
- Utiliza el modelo DialoGPT para generar respuestas contextuales.
- Implementa sampling con temperatura y top-k/top-p para diversificar las respuestas.
- Incluye respuestas de respaldo para manejar entradas inesperadas.

Características Clave:

Enfoque híbrido que combina generación de respuestas basadas en reglas y neuronales.
Comprensión contextual mediante historial de conversación.
Parámetros configurables de respuesta para controlar la calidad del output.
Manejo de errores y degradación elegante.

Interacción de Ejemplo:

Bot: Hello! How can I help you today? (type 'quit' to exit)
You: Hi there!
Bot: Hello! How are you doing today?
You: I'm doing great, thanks for asking!
Bot: That's wonderful to hear! Is there anything specific you'd like to chat about?
You: Can you tell me about machine learning?
Bot: Machine learning is a fascinating field of AI that allows computers to learn from data...
You: quit
Bot: Goodbye!

Esta implementación demuestra cómo los chatbots modernos combinan sistemas basados en reglas con modelos de lenguaje neuronal para crear conversaciones más naturales y atractivas.

Generación de Contenido

Generar contenido contextualmente apropiado al comprender terminología específica de la industria y convenciones de escritura
Adaptar el estilo de escritura según la demografía del público objetivo, desde publicaciones informales en blogs hasta documentos académicos formales
Crear variaciones de contenido para diferentes plataformas mientras preservan el mensaje principal
Asistir en tareas de escritura creativa sugiriendo desarrollos de la trama, descripciones de personajes y diálogos
Auto-generar informes, resúmenes y documentación a partir de datos estructurados

Ejemplo: Generación de Contenido con GPT

A continuación, se presenta una implementación de un generador de contenido que puede crear diferentes tipos de contenido con estilos y tonos específicos:

from openai import OpenAI
import os

class ContentGenerator:
    def __init__(self):
        # Initialize OpenAI client
        self.client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))
        
        # Define content styles
        self.styles = {
            'formal': "In a professional and academic tone, ",
            'casual': "In a friendly and conversational way, ",
            'technical': "Using technical terminology, ",
            'creative': "In a creative and engaging style, "
        }
        
    def generate_content(self, prompt, style='formal', max_length=500, 
                        temperature=0.7):
        try:
            # Apply style to prompt
            styled_prompt = self.styles.get(style, "") + prompt
            
            # Generate content using GPT-4
            response = self.client.chat.completions.create(
                model="gpt-4",
                messages=[
                    {"role": "system", "content": "You are a professional content writer."},
                    {"role": "user", "content": styled_prompt}
                ],
                max_tokens=max_length,
                temperature=temperature,
                top_p=0.95,
                frequency_penalty=0.5,
                presence_penalty=0.5
            )
            
            # Extract and clean up the generated text
            generated_text = response.choices[0].message.content
            return self.clean_text(generated_text)
            
        except Exception as e:
            return f"Error generating content: {str(e)}"
    
    def clean_text(self, text):
        # Remove the style prompt if present
        for style_prompt in self.styles.values():
            if text.startswith(style_prompt):
                text = text[len(style_prompt):]
        return text.strip()
    
    def generate_article(self, topic, style='formal', sections=3):
        """Generate a structured article with multiple sections"""
        article = []
        
        # Generate introduction
        intro_prompt = f"Write an introduction about {topic}"
        article.append(self.generate_content(intro_prompt, style, 200))
        
        # Generate main sections
        for i in range(sections):
            section_prompt = f"Write section {i+1} about {topic}"
            article.append(self.generate_content(section_prompt, style, 300))
        
        # Generate conclusion
        conclusion_prompt = f"Write a conclusion about {topic}"
        article.append(self.generate_content(conclusion_prompt, style, 200))
        
        return "\n\n".join(article)

# Example usage
if __name__ == "__main__":
    # Ensure you have set your OpenAI API key in environment variables
    if not os.getenv('OPENAI_API_KEY'):
        print("Please set your OPENAI_API_KEY environment variable")
        exit(1)
        
    generator = ContentGenerator()
    
    # Generate a blog post
    topic = "The Impact of Artificial Intelligence on Healthcare"
    print("Generating article...")
    article = generator.generate_article(
        topic,
        style='technical',
        sections=3
    )
    print("\nGenerated Article:")
    print(article)

Desglosemos la implementación de la clase ContentGenerator:

1. Inicialización y Estructura de la Clase

La clase utiliza la API de OpenAI para la generación de contenido.
Define diferentes estilos de contenido (formal, informal, técnico, creativo) con instrucciones de tono correspondientes.

2. Métodos Principales

La clase cuenta con tres métodos principales:

generate_content():
- Recibe un prompt, estilo y parámetros para la generación de contenido.
- Utiliza GPT-4 para generar contenido con los parámetros especificados.
- Incluye manejo de errores y limpieza de texto.
clean_text():
- Elimina las indicaciones de estilo del texto generado.
- Devuelve el texto limpio y sin formato adicional.
generate_article():
- Crea un artículo estructurado con introducción, secciones principales y conclusión.
- Permite la personalización del estilo y el número de secciones.
- Combina múltiples generaciones de contenido en una pieza cohesiva.

3. Características Clave

Control de temperatura (0.7) para equilibrar la creatividad.
Penalizaciones de frecuencia y presencia para reducir repeticiones.
Uso de variables de entorno para la seguridad de la clave API.
Manejo de errores estructurado a lo largo del proceso de generación.

4. Ejemplo de Uso

El código incluye un ejemplo práctico que:

Verifica la configuración adecuada de la clave API.
Genera un artículo técnico sobre la IA en la atención médica.
Crea una pieza estructurada con múltiples secciones.

Ejemplo de Salida:

Artículo Generado: El Impacto de la Inteligencia Artificial en la Atención Médica

The integration of Artificial Intelligence (AI) in healthcare represents a revolutionary transformation in medical practice and patient care. Recent advancements in machine learning algorithms and data analytics have enabled healthcare providers to leverage AI technologies for improved diagnosis, treatment planning, and patient outcomes. This technological evolution promises to enhance healthcare delivery while reducing costs and improving accessibility.

The primary impact of AI in healthcare is evident in diagnostic accuracy and efficiency. Machine learning algorithms can analyze medical imaging data with remarkable precision, helping radiologists detect abnormalities in X-rays, MRIs, and CT scans. These AI systems can process vast amounts of imaging data in seconds, highlighting potential areas of concern and providing probability scores for various conditions. This capability not only accelerates the diagnostic process but also reduces the likelihood of human error.

Patient care and monitoring have been revolutionized through AI-powered systems. Smart devices and wearable technologies equipped with AI algorithms can continuously monitor vital signs, predict potential health complications, and alert healthcare providers to emergency situations before they become critical. This proactive approach to patient care has shown significant promise in reducing hospital readmission rates and improving patient outcomes, particularly for those with chronic conditions.

In conclusion, AI's integration into healthcare systems represents a paradigm shift in medical practice. While challenges remain regarding data privacy, regulatory compliance, and ethical considerations, the potential benefits of AI in healthcare are undeniable. As technology continues to evolve, we can expect AI to play an increasingly central role in shaping the future of healthcare delivery and patient care.

Extracción de Información

Estas capacidades hacen que la extracción de información sea esencial para:

La síntesis automatizada de investigaciones, procesando miles de artículos académicos para extraer hallazgos clave
El análisis de documentos legales, permitiendo la revisión rápida de contratos y jurisprudencia
El procesamiento de registros médicos, extrayendo historiales de pacientes, diagnósticos y planes de tratamiento a partir de notas clínicas
La inteligencia empresarial, recopilando información competitiva de artículos de noticias e informes

Aquí tienes un ejemplo completo de extracción de información utilizando spaCy:

import spacy
import pandas as pd
from typing import List, Dict

class InformationExtractor:
    def __init__(self):
        # Load English language model
        self.nlp = spacy.load("en_core_web_sm")
        
    def extract_entities(self, text: str) -> List[Dict]:
        """Extract named entities from text."""
        doc = self.nlp(text)
        entities = []
        
        for ent in doc.ents:
            entities.append({
                'text': ent.text,
                'label': ent.label_,
                'start': ent.start_char,
                'end': ent.end_char
            })
        
        return entities
    
    def extract_relationships(self, text: str) -> List[Dict]:
        """Extract relationships between entities."""
        doc = self.nlp(text)
        relationships = []
        
        for token in doc:
            if token.dep_ in ('nsubj', 'dobj'):  # subject or object
                subject = token.text
                verb = token.head.text
                obj = [w.text for w in token.head.children if w.dep_ == 'dobj']
                
                if obj:
                    relationships.append({
                        'subject': subject,
                        'verb': verb,
                        'object': obj[0]
                    })
        
        return relationships
    
    def extract_key_phrases(self, text: str) -> List[str]:
        """Extract important phrases based on dependency parsing."""
        doc = self.nlp(text)
        phrases = []
        
        for chunk in doc.noun_chunks:
            if chunk.root.dep_ in ('nsubj', 'dobj', 'pobj'):
                phrases.append(chunk.text)
                
        return phrases

# Example usage
if __name__ == "__main__":
    extractor = InformationExtractor()
    
    sample_text = """
    Apple Inc. CEO Tim Cook announced a new iPhone launch in Cupertino, 
    California on September 12, 2024. The event will showcase revolutionary 
    AI features. Microsoft and Google are also planning similar events.
    """
    
    # Extract entities
    entities = extractor.extract_entities(sample_text)
    print("\nExtracted Entities:")
    print(pd.DataFrame(entities))
    
    # Extract relationships
    relationships = extractor.extract_relationships(sample_text)
    print("\nExtracted Relationships:")
    print(pd.DataFrame(relationships))
    
    # Extract key phrases
    phrases = extractor.extract_key_phrases(sample_text)
    print("\nKey Phrases:")
    print(phrases)

Analicemos la clase InformationExtractor que utiliza spaCy para el procesamiento de lenguaje natural:

1. Configuración de la Clase y Dependencias

Utiliza spaCy para el procesamiento de NLP y pandas para la manipulación de datos.
Se inicializa con el modelo de lenguaje en inglés de spaCy (en_core_web_sm).

2. Métodos Principales

La clase contiene tres métodos clave de extracción:

extract_entities():
- Identifica entidades nombradas en el texto.
- Devuelve una lista de diccionarios con el texto de la entidad, la etiqueta y la posición.
- Captura elementos como organizaciones, personas y ubicaciones.
extract_relationships():
- Encuentra conexiones entre sujetos y objetos.
- Utiliza análisis de dependencias para identificar relaciones.
- Devuelve relaciones sujeto-verbo-objeto.
extract_key_phrases():
- Extrae frases nominales importantes.
- Utiliza análisis de dependencias para identificar frases significativas.
- Se centra en sujetos, objetos y objetos preposicionales.

3. Ejemplo de Uso

El código demuestra una aplicación práctica con un texto de ejemplo sobre Apple Inc. y muestra tres tipos de salida:

Entidades: Identifica compañías (Apple Inc., Microsoft, Google), personas (Tim Cook), ubicaciones (Cupertino, California) y fechas.
Relaciones: Extrae conexiones sujeto-verbo-objeto como "Cook announced launch".
Frases Clave: Extrae frases nominales importantes del texto.

4. Características Clave

Utiliza modelos preentrenados para un reconocimiento preciso de entidades.
Implementa análisis de dependencias para la extracción de relaciones.
Puede manejar estructuras de oraciones complejas.
Produce datos estructurados adecuados para análisis posteriores.

Ejemplo de Salida:

# Extracted Entities:
#              text     label  start  end
# 0        Apple Inc.     ORG      1   10
# 1        Tim Cook    PERSON     15   23
# 2        Cupertino     GPE     47   56
# 3      California     GPE     58   68
# 4    September 12     DATE     72   84
# 5            2024     DATE     86   90
# 6       Microsoft     ORG    146  154
# 7          Google     ORG    159  165

# Extracted Relationships:
#    subject    verb     object
# 0     Cook announced   launch
# 1    event     will  showcase

# Key Phrases:
# ['Apple Inc. CEO', 'new iPhone launch', 'revolutionary AI features', 
#  'similar events']

Características Clave:

Utiliza modelos preentrenados de spaCy para un reconocimiento preciso de entidades.
Implementa análisis de dependencias para la extracción de relaciones.
Maneja estructuras de oraciones complejas y múltiples tipos de entidades.
Devuelve datos estructurados adecuados para análisis posteriores.

Aplicaciones:

Análisis automatizado de documentos en contextos legales y empresariales.
Monitoreo de noticias y redes sociales.
Análisis de artículos de investigación y extracción de conocimiento.
Análisis de comentarios y opiniones de clientes.

1.1.3 Un Flujo de Trabajo Simple de NLP

Para ver NLP en acción, consideremos un ejemplo sencillo: analizar el sentimiento de una oración.

Oración: I love this book; it’s truly inspiring!

Flujo de Trabajo:

Tokenización: Dividir la oración en palabras individuales o tokens:

from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords
from nltk import pos_tag
import string

def analyze_text(text):
    # Sentence tokenization
    sentences = sent_tokenize(text)
    print("\n1. Sentence Tokenization:")
    print(sentences)
    
    # Word tokenization
    tokens = word_tokenize(text)
    print("\n2. Word Tokenization:")
    print(tokens)
    
    # Remove punctuation
    tokens_no_punct = [token for token in tokens if token not in string.punctuation]
    print("\n3. After Punctuation Removal:")
    print(tokens_no_punct)
    
    # Convert to lowercase and remove stopwords
    stop_words = set(stopwords.words('english'))
    clean_tokens = [token.lower() for token in tokens_no_punct 
                   if token.lower() not in stop_words]
    print("\n4. After Stopword Removal:")
    print(clean_tokens)
    
    # Part-of-speech tagging
    pos_tags = pos_tag(tokens)
    print("\n5. Part-of-Speech Tags:")
    print(pos_tags)

# Example usage
text = "I love this book; it's truly inspiring! The author writes beautifully."
analyze_text(text)

# Output:
# 1. Sentence Tokenization:
# ['I love this book; it's truly inspiring!', 'The author writes beautifully.']

# 2. Word Tokenization:
# ['I', 'love', 'this', 'book', ';', 'it', ''', 's', 'truly', 'inspiring', '!', 
#  'The', 'author', 'writes', 'beautifully', '.']

# 3. After Punctuation Removal:
# ['I', 'love', 'this', 'book', 'it', 's', 'truly', 'inspiring', 
#  'The', 'author', 'writes', 'beautifully']

# 4. After Stopword Removal:
# ['love', 'book', 'truly', 'inspiring', 'author', 'writes', 'beautifully']

# 5. Part-of-Speech Tags:
# [('I', 'PRP'), ('love', 'VBP'), ('this', 'DT'), ('book', 'NN'), ...]

Desglose del Código:

Importaciones:
- word_tokenize, sent_tokenize: Para dividir el texto en palabras y oraciones.
- stopwords: Para eliminar palabras comunes.
- pos_tag: Para etiquetado de partes del discurso (POS).
- string: Para acceder a los signos de puntuación.
Función analyze_text:
- Recibe una cadena de texto como entrada.
- Procesa el texto a través de múltiples pasos de NLP.
- Imprime los resultados en cada etapa.
Pasos de Procesamiento:
- Tokenización de Oraciones: Divide el texto en oraciones individuales.
- Tokenización de Palabras: Divide las oraciones en palabras o tokens individuales.
- Eliminación de Puntuación: Filtra los signos de puntuación.
- Eliminación de Palabras Vacías: Elimina palabras comunes y convierte el texto a minúsculas.
- Etiquetado POS: Etiqueta cada palabra con su parte del discurso correspondiente.

Características Clave:

Maneja múltiples oraciones.
Mantiene el orden de procesamiento para un análisis claro del texto.
Demuestra múltiples capacidades de NLTK.
Incluye salidas detalladas en cada paso.

Eliminación de Palabras Vacías: Un paso crucial de preprocesamiento que mejora el análisis de texto al eliminar palabras comunes (stopwords) que tienen un valor semántico mínimo. Estas incluyen artículos (a, an, the), pronombres (I, you, it), preposiciones (in, at, on) y ciertos verbos auxiliares (is, are, was). Al eliminar estas palabras de alta frecuencia pero baja información, podemos centrarnos en los términos portadores de contenido que realmente transmiten el significado del mensaje. Este proceso mejora significativamente la eficiencia de tareas como modelado de temas, clasificación de documentos y recuperación de información.

from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
import string

def process_text(text):
    # Step 1: Tokenize the text
    tokens = word_tokenize(text)
    print("Original tokens:", tokens)
    
    # Step 2: Convert to lowercase
    tokens_lower = [token.lower() for token in tokens]
    print("\nLowercase tokens:", tokens_lower)
    
    # Step 3: Remove punctuation
    tokens_no_punct = [token for token in tokens_lower 
                      if token not in string.punctuation]
    print("\nTokens without punctuation:", tokens_no_punct)
    
    # Step 4: Remove stopwords
    stop_words = set(stopwords.words('english'))
    filtered_tokens = [token for token in tokens_no_punct 
                      if token not in stop_words]
    print("\nTokens without stopwords:", filtered_tokens)
    
    # Step 5: Get frequency distribution
    from collections import Counter
    word_freq = Counter(filtered_tokens)
    print("\nWord frequencies:", dict(word_freq))
    
    return filtered_tokens

# Example usage
text = "I love this inspiring book; it's truly amazing!"
processed_tokens = process_text(text)

# Output:
# Original tokens: ['I', 'love', 'this', 'inspiring', 'book', ';', 'it', "'s", 'truly', 'amazing', '!']
# Lowercase tokens: ['i', 'love', 'this', 'inspiring', 'book', ';', 'it', "'s", 'truly', 'amazing', '!']
# Tokens without punctuation: ['i', 'love', 'this', 'inspiring', 'book', 'it', 's', 'truly', 'amazing']
# Tokens without stopwords: ['love', 'inspiring', 'book', 'truly', 'amazing']
# Word frequencies: {'love': 1, 'inspiring': 1, 'book': 1, 'truly': 1, 'amazing': 1}

Desglose del Código:

Importaciones:
- stopwords: Acceso a las palabras vacías comunes del inglés.
- word_tokenize: Para dividir el texto en palabras.
- string: Para acceder a los signos de puntuación.
Función process_text:
- Recibe texto sin procesar como entrada.
- Realiza el procesamiento del texto paso a paso.
- Imprime los resultados en cada etapa para mayor claridad.
Pasos de Procesamiento:
- Tokenización: Divide el texto en palabras individuales.
- Normalización de Mayúsculas y Minúsculas: Convierte todo el texto a minúsculas.
- Eliminación de Puntuación: Elimina todos los signos de puntuación.
- Eliminación de Palabras Vacías: Filtra las palabras comunes.
- Análisis de Frecuencia: Cuenta las ocurrencias de las palabras.
Mejoras Clave:
- Se añadió una visualización paso a paso.
- Se incluyó el análisis de frecuencia.
- Se mejoró la organización del código.
- Se añadió documentación completa.
Análisis de Sentimientos:
Un paso crucial que evalúa el tono emocional del texto al analizar la elección de palabras y el contexto. Este proceso asigna valores numéricos para expresar la positividad, negatividad o neutralidad del contenido. Usando técnicas avanzadas de procesamiento de lenguaje natural, el análisis de sentimientos puede detectar matices emocionales sutiles, sarcasmo y estados emocionales complejos. En nuestro flujo de trabajo, aplicamos el análisis de sentimientos al texto filtrado después de pasos de preprocesamiento como tokenización y eliminación de palabras vacías para garantizar una evaluación emocional más precisa.

from textblob import TextBlob
import numpy as np
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords

def analyze_sentiment(text):
    # Initialize stopwords
    stop_words = set(stopwords.words('english'))
    
    # Tokenize and filter
    tokens = word_tokenize(text)
    filtered_tokens = [word for word in tokens if word.lower() not in stop_words]
    
    # Create TextBlob object
    blob = TextBlob(" ".join(filtered_tokens))
    
    # Get sentiment scores
    polarity = blob.sentiment.polarity
    subjectivity = blob.sentiment.subjectivity
    
    # Determine sentiment category
    if polarity > 0:
        category = "Positive"
    elif polarity < 0:
        category = "Negative"
    else:
        category = "Neutral"
    
    # Return detailed analysis
    return {
        'polarity': polarity,
        'subjectivity': subjectivity,
        'category': category,
        'filtered_tokens': filtered_tokens
    }

# Example usage
text = "I absolutely love this amazing book! It's truly inspiring and enlightening."
results = analyze_sentiment(text)

print(f"Original Text: {text}")
print(f"Filtered Tokens: {results['filtered_tokens']}")
print(f"Sentiment Polarity: {results['polarity']:.2f}")
print(f"Subjectivity Score: {results['subjectivity']:.2f}")
print(f"Sentiment Category: {results['category']}")

# Output:
# Original Text: I absolutely love this amazing book! It's truly inspiring and enlightening.
# Filtered Tokens: ['absolutely', 'love', 'amazing', 'book', 'truly', 'inspiring', 'enlightening']
# Sentiment Polarity: 0.85
# Subjectivity Score: 0.75
# Sentiment Category: Positive

Desglose del Código:

Importaciones:
- TextBlob: Para análisis de sentimientos.
- numpy: Para operaciones numéricas.
- Componentes de NLTK: Para el preprocesamiento de texto.
Función analyze_sentiment:
- Recibe texto sin procesar como entrada.
- Elimina palabras vacías para un análisis más limpio.
- Calcula tanto la polaridad como los puntajes de subjetividad.
- Categoriza el sentimiento como Positivo, Negativo o Neutral.
Características Clave:
- Preprocesamiento completo con eliminación de palabras vacías.
- Múltiples métricas de sentimiento (polaridad y subjetividad).
- Categorización clara del sentimiento.
- Resultados detallados en formato de diccionario.
Explicación de la Salida:
- Polaridad: Rango de -1 (negativo) a 1 (positivo).
- Subjetividad: Rango de 0 (objetivo) a 1 (subjetivo).
- Categoría: Clasificación simple del sentimiento general.

1.1.4 NLP en la Vida Cotidiana

Ejercicio Práctico: Crear un Pipeline Simple de NLP

Construyamos un pipeline básico de NLP que combine los pasos discutidos:

from nltk.tokenize import word_tokenize, sent_tokenize
from nltk.corpus import stopwords
from textblob import TextBlob
import string
from collections import Counter
import re

class TextAnalyzer:
    def __init__(self):
        self.stop_words = set(stopwords.words('english'))
        
    def preprocess_text(self, text):
        # Remove special characters and digits
        text = re.sub(r'[^\w\s]', '', text)
        
        # Convert to lowercase
        text = text.lower()
        
        return text
        
    def analyze_text(self, text):
        # Store original text
        original_text = text
        
        # Step 1: Preprocess
        text = self.preprocess_text(text)
        
        # Step 2: Sentence tokenization
        sentences = sent_tokenize(text)
        
        # Step 3: Word tokenization
        tokens = word_tokenize(text)
        
        # Step 4: Remove stopwords
        filtered_tokens = [word for word in tokens if word not in self.stop_words]
        
        # Step 5: Calculate word frequency
        word_freq = Counter(filtered_tokens)
        
        # Step 6: Sentiment analysis
        blob = TextBlob(original_text)
        sentiment = blob.sentiment
        
        # Step 7: Return comprehensive analysis
        return {
            'original_text': original_text,
            'sentences': sentences,
            'tokens': tokens,
            'filtered_tokens': filtered_tokens,
            'word_frequency': dict(word_freq),
            'sentiment_polarity': sentiment.polarity,
            'sentiment_subjectivity': sentiment.subjectivity,
            'sentence_count': len(sentences),
            'word_count': len(tokens),
            'unique_words': len(set(tokens))
        }

def main():
    analyzer = TextAnalyzer()
    
    # Get input from user
    text = input("Enter text to analyze: ")
    
    # Perform analysis
    results = analyzer.analyze_text(text)
    
    # Display results
    print("\n=== Text Analysis Results ===")
    print(f"\nOriginal Text: {results['original_text']}")
    print(f"\nNumber of Sentences: {results['sentence_count']}")
    print(f"Total Words: {results['word_count']}")
    print(f"Unique Words: {results['unique_words']}")
    print("\nTokens:", results['tokens'])
    print("\nFiltered Tokens (stopwords removed):", results['filtered_tokens'])
    print("\nWord Frequency:", results['word_frequency'])
    print(f"\nSentiment Analysis:")
    print(f"Polarity: {results['sentiment_polarity']:.2f} (-1 negative to 1 positive)")
    print(f"Subjectivity: {results['sentiment_subjectivity']:.2f} (0 objective to 1 subjective)")

if __name__ == "__main__":
    main()

Desglose del Código:

Estructura de la Clase:
- La clase TextAnalyzer encapsula toda la funcionalidad de análisis.
- La inicialización configura las palabras vacías para reutilización.
- Los métodos están organizados para una clara separación de responsabilidades.
Componentes Clave:
- preprocess_text: Limpia y normaliza el texto de entrada.
- analyze_text: Método principal que realiza un análisis integral.
- main: Gestiona la interacción con el usuario y la visualización de resultados.
Características del Análisis:
- Tokenización de oraciones para análisis estructural.
- Tokenización de palabras y eliminación de palabras vacías.
- Cálculo de frecuencia de palabras.
- Análisis de sentimientos (polaridad y subjetividad).
- Estadísticas del texto (conteo de palabras, palabras únicas, etc.).
Mejoras sobre el Original:
- Diseño orientado a objetos para mejor organización.
- Métricas de análisis de texto más completas.
- Mejor manejo de errores y preprocesamiento del texto.
- Formateo detallado de la salida.
- Estructura de clase reutilizable.

Este ejemplo proporciona un pipeline robusto y completo de análisis de texto, adecuado tanto para fines educativos como para aplicaciones prácticas.

1.1.5 Conclusiones Clave

El NLP permite que las máquinas comprendan e interactúen con el lenguaje humano, una capacidad fundamental que les permite procesar, analizar y generar texto de forma similar a los humanos. A través de algoritmos sofisticados y modelos de aprendizaje automático, los sistemas de NLP pueden comprender el contexto, el sentimiento e incluso matices lingüísticos sutiles.
Las técnicas fundamentales del NLP incluyen:
- Tokenización: Divide el texto en unidades significativas (palabras u oraciones).
- Eliminación de Palabras Vacías: Filtra palabras comunes para centrarse en contenido significativo.
- Análisis de Sentimientos: Determina el tono emocional y el significado subjetivo.
Aplicaciones del NLP en el mundo real:
- Chatbots que proporcionan atención al cliente e información.
- Sistemas de traducción automática que superan barreras lingüísticas.
- Herramientas de resumen de texto que condensan documentos extensos.
- Asistentes de voz que comprenden y responden al habla natural.
- Sistemas de recomendación de contenido que analizan preferencias de los usuarios.

Compra este libro