Tutorial ScikitLearn: Técnicas avanzadas de extracción de características

Introducción a word embeddings (Word2Vec, GloVe)

Los word embeddings son representaciones vectoriales de palabras que capturan sus significados y relaciones semánticas en un espacio continuo. A diferencia de las representaciones tradicionales basadas en conteos, como el modelo Bag of Words, los embeddings permiten que palabras con significados similares tengan representaciones vectoriales cercanas en el espacio multidimensional.

Word2Vec

Word2Vec es una técnica popular desarrollada por investigadores de Google que utiliza redes neuronales para aprender representaciones vectoriales de palabras a partir de grandes corpus de texto. Existen dos arquitecturas principales en Word2Vec:

• CBOW (Continuous Bag of Words): Predice una palabra objetivo basada en su contexto (palabras circundantes).
• Skip-gram: Predice el contexto de una palabra objetivo dada.

Ambas arquitecturas optimizan los vectores de palabras para que capturen relaciones semánticas y sintácticas, permitiendo operaciones como analogías: por ejemplo, rey - hombre + mujer ≈ reina.

Ejemplo de uso con Gensim:

from gensim.models import Word2Vec

# Supongamos que 'sentences' es una lista de listas de palabras tokenizadas
model = Word2Vec(sentences, vector_size=100, window=5, min_count=1, workers=4)

# Obtener el vector de una palabra
vector_rey = model.wv['rey']

# Encontrar palabras similares
similares = model.wv.most_similar('rey', topn=5)
print(similares)

GloVe

GloVe (Global Vectors for Word Representation) es otra técnica de word embeddings desarrollada por investigadores de Stanford. A diferencia de Word2Vec, que se basa en la predicción local del contexto, GloVe utiliza matrices de coocurrencia globales para capturar las estadísticas de ocurrencia de palabras en todo el corpus.

La principal ventaja de GloVe es su capacidad para incorporar información global del corpus durante el entrenamiento, lo que a menudo resulta en representaciones más precisas de relaciones semánticas.

Ejemplo de uso con la librería glove-python:

from glove import Corpus, Glove

# Crear un corpus a partir de las frases tokenizadas
corpus = Corpus()
corpus.fit(sentences, window=5)

# Entrenar el modelo GloVe
glove = Glove(no_components=100, learning_rate=0.05)
glove.fit(corpus.matrix, epochs=30, no_threads=4, verbose=True)
glove.add_dictionary(corpus.dictionary)

# Obtener el vector de una palabra
vector_reina = glove.word_vectors[glove.dictionary['reina']]

# Encontrar palabras similares
similares = glove.most_similar('reina', number=5)
print(similares)

Comparativa entre Word2Vec y GloVe

Ambas técnicas buscan representar palabras en un espacio vectorial de manera que las relaciones semánticas se preserven. Sin embargo, difieren en su enfoque:

• Word2Vec: Se enfoca en la predicción de palabras dentro de su contexto inmediato, optimizando las representaciones de forma local.
• GloVe: Utiliza estadísticas globales de coocurrencia de palabras, aprovechando la información de todo el corpus para generar los embeddings.

La elección entre Word2Vec y GloVe puede depender de la naturaleza del corpus y de los requisitos específicos del proyecto. Ambos métodos han demostrado ser efectivos en diversas tareas de procesamiento de lenguaje natural.

Integración de embeddings pre-entrenados en Scikit Learn

La integración de embeddings pre-entrenados en Scikit Learn permite aprovechar representaciones vectoriales de palabras ya aprendidas en grandes corpus de texto, mejorando así la eficacia de los modelos de procesamiento de lenguaje natural (NLP). Al utilizar embeddings pre-entrenados como Word2Vec, GloVe o FastText, se puede capturar información semántica y sintáctica rica sin necesidad de entrenar modelos desde cero, lo que ahorra tiempo y recursos computacionales.

Ventajas de utilizar embeddings pre-entrenados

• Eficiencia en el entrenamiento: Reducen el tiempo necesario para entrenar modelos, ya que las representaciones de palabras ya están aprendidas.
• Mejora de la precisión: Capturan relaciones complejas entre palabras, lo que puede llevar a mejores resultados en tareas de NLP.
• Transferencia de conocimiento: Permiten transferir el conocimiento adquirido en un corpus a diferentes aplicaciones y dominios.

Implementación en Scikit Learn

Scikit Learn no proporciona directamente funcionalidades para manejar embeddings pre-entrenados, pero se puede integrar fácilmente utilizando transformadores personalizados o combinando con otras librerías como Gensim o TensorFlow. A continuación, se presenta un ejemplo de cómo integrar embeddings pre-entrenados de GloVe en un pipeline de Scikit Learn.

• Paso 1: Cargar los embeddings pre-entrenados

Primero, es necesario descargar y cargar los embeddings pre-entrenados. En este ejemplo, utilizaremos los vectores de GloVe.

import numpy as np

# Ruta al archivo de embeddings GloVe
glove_file = 'glove.6B.100d.txt'

# Cargar los embeddings en un diccionario
embeddings_index = {}
with open(glove_file, encoding='utf-8') as f:
    for line in f:
        valores = line.split()
        palabra = valores[0]
        vector = np.asarray(valores[1:], dtype='float32')
        embeddings_index[palabra] = vector

print(f'Número de embeddings cargados: {len(embeddings_index)}')

Salida:

• Paso 2: Crear una matriz de embeddings para el conjunto de datos

Supongamos que tenemos un conjunto de datos de texto y queremos convertir cada documento en una representación vectorial utilizando los embeddings pre-entrenados.

from sklearn.base import TransformerMixin

class EmbeddingVectorizer(TransformerMixin):
    def __init__(self, embeddings_index, dim=100):
        self.embeddings_index = embeddings_index
        self.dim = dim
    
    def fit(self, X, y=None):
        return self
    
    def transform(self, X):
        return np.array([
            np.mean([self.embeddings_index.get(w, np.zeros(self.dim)) for w in words.split()], axis=0)
            for words in X
        ])

# Ejemplo de uso con un conjunto de datos de texto
corpus = [
    'el rápido zorro marrón salta sobre el perro perezoso',
    'la inteligencia artificial está revolucionando el mundo',
    'el aprendizaje automático es una rama de la inteligencia artificial'
]

vectorizer = EmbeddingVectorizer(embeddings_index, dim=100)
X_embedded = vectorizer.transform(corpus)
print(X_embedded.shape)  # Debería mostrar (número_de_documentos, 100)

• Paso 3: Integrar los embeddings en un pipeline de Scikit Learn

Para facilitar el proceso de preprocesamiento y modelado, se puede crear un pipeline que incluya la transformación de texto a embeddings y el modelo de clasificación o regresión.

from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Etiquetas de ejemplo
y = [0, 1, 1]

# Dividir el conjunto de datos
X_train, X_test, y_train, y_test = train_test_split(corpus, y, test_size=0.33, random_state=42)

# Crear el pipeline
pipeline = Pipeline([
    ('embedding', EmbeddingVectorizer(embeddings_index, dim=100)),
    ('clf', LogisticRegression())
], memory = None)

# Entrenar el modelo
pipeline.fit(X_train, y_train)

# Realizar predicciones
y_pred = pipeline.predict(X_test)

# Evaluar el modelo
accuracy = accuracy_score(y_test, y_pred)
print(f'Precisión del modelo: {accuracy:.2f}')

Consideraciones al utilizar embeddings pre-entrenados

• Cobertura del vocabulario: Es posible que algunas palabras del conjunto de datos no estén presentes en los embeddings pre-entrenados. En tales casos, se puede optar por ignorar estas palabras o asignarles un vector de ceros.
• Dimensionalidad de los embeddings: Es importante asegurarse de que la dimensionalidad de los embeddings pre-entrenados coincida con la utilizada en el modelo. En caso contrario, se deben ajustar o transformar los vectores según sea necesario.
• Alineación con el dominio del problema: Los embeddings pre-entrenados están entrenados en corpus generales. Si se trabaja en un dominio específico, puede ser beneficioso ajustar o reentrenar los embeddings para capturar mejor las particularidades del dominio.

La integración de embeddings pre-entrenados en Scikit Learn potencia las capacidades de los modelos de NLP, permitiendo aprovechar representaciones ricas y semánticamente informativas de las palabras, lo que se traduce en mejoras significativas en diversas tareas de procesamiento de lenguaje natural.

Ingeniería de características para mejorar modelos

La ingeniería de características es un proceso fundamental en el desarrollo de modelos de aprendizaje automático, ya que implica la creación, transformación y selección de variables que mejoran el rendimiento predictivo de los modelos. En el contexto de procesamiento de lenguaje natural (NLP), la ingeniería de características se enfoca en transformar datos textuales en representaciones numéricas que capturen la información relevante para la tarea específica.

Técnicas de ingeniería de características en NLP

Una adecuada ingeniería de características puede significar la diferencia entre un modelo mediocre y uno altamente eficaz. A continuación, se presentan algunas técnicas avanzadas para mejorar los modelos de NLP:

1. Vectorización de texto avanzada

Más allá de las representaciones básicas como Bag of Words o TF-IDF, existen métodos más sofisticados que capturan mejor las relaciones semánticas entre palabras.

Ejemplo con TfidfVectorizer de Scikit Learn:

from sklearn.feature_extraction.text import TfidfVectorizer

corpus = [
    'el rápido zorro marrón salta sobre el perro perezoso',
    'la inteligencia artificial está revolucionando el mundo',
    'el aprendizaje automático es una rama de la inteligencia artificial'
]

vectorizer = TfidfVectorizer(ngram_range=(1, 2), max_features=5000)
X_tfidf = vectorizer.fit_transform(corpus)

print(X_tfidf.shape)  # Debería mostrar (3, número_de_características)

2. Extracción de características sintácticas

Incorporar información sintáctica como partes del habla (POS) puede enriquecer las representaciones de texto.

Ejemplo utilizando nltk para etiquetado POS y Scikit Learn para vectorización:

import nltk
from sklearn.feature_extraction.text import CountVectorizer

nltk.download('averaged_perceptron_tagger')
nltk.download('averaged_perceptron_tagger_eng')
nltk.download('punkt')

def pos_tagging(text):
    tokens = nltk.word_tokenize(text)
    pos_tags = nltk.pos_tag(tokens)
    return ' '.join([f"{word}_{tag}" for word, tag in pos_tags])

corpus = [
    'el rápido zorro marrón salta sobre el perro perezoso',
    'la inteligencia artificial está revolucionando el mundo',
    'el aprendizaje automático es una rama de la inteligencia artificial'
]

corpus_pos = [pos_tagging(doc) for doc in corpus]

vectorizer = CountVectorizer()
X_pos = vectorizer.fit_transform(corpus_pos)

print(X_pos.shape)  # Debería mostrar (3, número_de_características)

3. Incorporación de entidades nombradas

Detectar y utilizar entidades nombradas (como nombres de personas, lugares, organizaciones) puede mejorar la capacidad del modelo para captar información relevante.

Ejemplo utilizando spaCy para reconocimiento de entidades:

import spacy
from sklearn.feature_extraction.text import CountVectorizer

nlp = spacy.load('es_core_news_sm')

def extract_entities(text):
    doc = nlp(text)
    return ' '.join([ent.text for ent in doc.ents])

corpus = [
    'Juan trabaja en OpenAI y vive en Madrid',
    'María estudia en la Universidad de Barcelona',
    'Carlos visitó la Torre Eiffel en París'
]

corpus_entities = [extract_entities(doc) for doc in corpus]

vectorizer = CountVectorizer()
X_entities = vectorizer.fit_transform(corpus_entities)

print(X_entities.shape)  # Debería mostrar (3, número_de_características)

4. Creación de características basadas en contexto

Utilizar ventanas de contexto para capturar la relación entre palabras cercanas puede proporcionar información adicional al modelo.

Ejemplo utilizando CountVectorizer con n-gramas:

from sklearn.feature_extraction.text import CountVectorizer

corpus = [
    'el rápido zorro marrón salta sobre el perro perezoso',
    'la inteligencia artificial está revolucionando el mundo',
    'el aprendizaje automático es una rama de la inteligencia artificial'
]

vectorizer = CountVectorizer(ngram_range=(2, 3), max_features=3000)
X_context = vectorizer.fit_transform(corpus)

print(X_context.shape)  # Debería mostrar (3, número_de_características)

5. Reducción de dimensionalidad para características avanzadas

Después de crear características complejas, es posible que el espacio de características sea demasiado grande. Técnicas como PCA pueden ayudar a reducir la dimensionalidad manteniendo la información esencial.

Ejemplo combinando TfidfVectorizer y PCA:

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import PCA

corpus = [
    'el rápido zorro marrón salta sobre el perro perezoso',
    'la inteligencia artificial está revolucionando el mundo',
    'el aprendizaje automático es una rama de la inteligencia artificial'
]

vectorizer = TfidfVectorizer(max_features=1000)
X_tfidf = vectorizer.fit_transform(corpus).toarray()

pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_tfidf)

print('Forma de X_pca:', X_pca.shape)  # Ahora debería mostrar (3, 2)

Consideraciones al realizar ingeniería de características

• Relevancia de las características: Es esencial que las características creadas sean relevantes para la tarea específica que se está abordando, ya sea clasificación, regresión u otra.
• Evitar la sobreajuste: La creación de demasiadas características puede llevar a que el modelo se ajuste demasiado a los datos de entrenamiento, disminuyendo su capacidad de generalización.
• Consistencia en el preprocesamiento: Asegurar que el preprocesamiento y la ingeniería de características se apliquen de manera consistente tanto en los conjuntos de entrenamiento como en los de prueba.
• Automatización con pipelines: Integrar las técnicas de ingeniería de características en pipelines de Scikit Learn facilita la reproducibilidad y la gestión eficiente del flujo de trabajo.

La ingeniería de características es una disciplina que requiere comprensión tanto del dominio de aplicación como de las técnicas de preprocesamiento disponibles. Al aplicar estrategias avanzadas de ingeniería de características, se potencia la capacidad de los modelos para captar patrones complejos y mejorar su rendimiento en tareas de procesamiento de lenguaje natural.

Combinación de datos textuales con otras modalidades

La combinación de datos textuales con otras modalidades es una estrategia esencial para enriquecer los modelos de procesamiento de lenguaje natural (NLP) y mejorar su rendimiento en tareas complejas. Al integrar información textual con otras fuentes de datos, como características numéricas, categóricas o de imágenes, se logra capturar una representación más completa y contextualizada de los datos, lo que facilita que los modelos aprendan patrones más robustos y precisos.

Estrategias para combinar diferentes tipos de datos

Existen diversas estrategias para integrar datos textuales con otras modalidades, cada una adaptada a las características específicas de los datos y a los objetivos del modelo. A continuación, se presentan algunas de las más efectivas:

• Concatenación de características: Consiste en unir las representaciones vectoriales de diferentes tipos de datos en un solo vector de características. Esta técnica es sencilla pero poderosa, ya que permite que el modelo aprenda de manera conjunta las distintas fuentes de información.
• Uso de ColumnTransformer: Scikit Learn proporciona el transformador ColumnTransformer, que facilita la aplicación de diferentes transformaciones a distintas columnas de un conjunto de datos. Esto es especialmente útil cuando se manejan datos heterogéneos.
• Pipelines personalizados: Mediante la creación de pipelines personalizados, se puede encadenar múltiples transformaciones y modelos, asegurando una integración fluida y reproducible de las diferentes modalidades de datos.

Implementación con Scikit Learn

A continuación, se muestra un ejemplo completo de cómo combinar datos textuales con características numéricas y categóricas utilizando Scikit Learn y Python. Este ejemplo ilustra la creación de un modelo de clasificación que integra diferentes tipos de datos para predecir una etiqueta específica.

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report

# Datos de ejemplo
data = {
    'texto': [
        'El rápido zorro marrón salta sobre el perro perezoso',
        'La inteligencia artificial está revolucionando el mundo',
        'El aprendizaje automático es una rama de la inteligencia artificial',
        'Data science combina estadísticas y programación',
        'Deep learning permite el reconocimiento de imágenes'
    ],
    'edad': [25, 30, 22, 35, 28],
    'genero': ['M', 'F', 'F', 'M', 'F'],
    'ingreso': [50000, 60000, 45000, 80000, 52000],
    'etiqueta': [0, 1, 1, 0, 1]
}

df = pd.DataFrame(data)

# División de los datos
X = df.drop('etiqueta', axis=1)
y = df['etiqueta']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Definición de las columnas
texto_col = 'texto'
num_cols = ['edad', 'ingreso']
cat_cols = ['genero']

# Pipeline para datos textuales
texto_pipeline = Pipeline([
    ('tfidf', TfidfVectorizer(max_features=100))
], memory = None)

# Pipeline para datos numéricos
num_pipeline = Pipeline([
    ('scaler', StandardScaler())
], memory = None)

# Pipeline para datos categóricos
cat_pipeline = Pipeline([
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
], memory = None)

# Combinación de pipelines
preprocessor = ColumnTransformer([
    ('texto', texto_pipeline, texto_col),
    ('num', num_pipeline, num_cols),
    ('cat', cat_pipeline, cat_cols)
])

# Pipeline completo con el modelo
model_pipeline = Pipeline([
    ('preprocessor', preprocessor),
    ('classifier', LogisticRegression())
], memory = None)

# Entrenamiento del modelo
model_pipeline.fit(X_train, y_train)

# Predicciones
y_pred = model_pipeline.predict(X_test)

# Evaluación
print(classification_report(y_test, y_pred))

Explicación del código

• Preparación de los datos: Se crea un DataFrame con datos de ejemplo que incluyen texto, características numéricas (edad, ingreso), y una característica categórica (genero). La etiqueta objetivo es una variable binaria (etiqueta).
• División de los datos: Se divide el conjunto de datos en conjuntos de entrenamiento y prueba utilizando train_test_split.
• Definición de pipelines:
  • Pipeline para texto: Utiliza TfidfVectorizer para convertir el texto en una representación numérica basada en TF-IDF, limitando el número de características a 100.
  • Pipeline para datos numéricos: Aplica StandardScaler para escalar las características numéricas, lo que es crucial para muchos algoritmos de aprendizaje automático.
  • Pipeline para datos categóricos: Emplea OneHotEncoder para convertir las características categóricas en una representación binaria adecuada para los modelos.
• Combinación de pipelines: Se utiliza ColumnTransformer para aplicar cada pipeline a las columnas correspondientes del conjunto de datos.
• Pipeline completo: Se encadena el preprocesador con un modelo de LogisticRegression, creando un flujo de trabajo integrado.
• Entrenamiento y evaluación: Se entrena el modelo con los datos de entrenamiento y se evalúa su rendimiento en el conjunto de prueba, mostrando un reporte de clasificación que incluye métricas como precisión, recall y f1-score.

Beneficios de la combinación de modalidades

• Mejora del rendimiento del modelo: Integrar diferentes tipos de datos permite que el modelo aproveche diversas fuentes de información, lo que puede traducirse en una mayor precisión y capacidad de generalización.
• Captura de relaciones complejas: Al combinar datos textuales con otras características, el modelo puede identificar interacciones y patrones que no serían evidentes utilizando únicamente una modalidad.
• Flexibilidad en el preprocesamiento: Utilizando herramientas como ColumnTransformer, es posible aplicar diferentes transformaciones específicas a cada tipo de dato de manera eficiente y organizada.

Consideraciones al combinar datos

• Compatibilidad de características: Es fundamental asegurarse de que las diferentes modalidades de datos sean compatibles y se complementen mutuamente, evitando redundancias o información irrelevante.
• Gestión de datos faltantes: Al combinar múltiples fuentes de datos, es común encontrar valores faltantes. Es importante implementar estrategias adecuadas de imputación o manejo de datos faltantes para mantener la integridad del modelo.
• Escalado y normalización: Diferentes tipos de datos pueden requerir distintas técnicas de escalado o normalización para asegurar que todas las características contribuyan de manera equilibrada al aprendizaje del modelo.

La combinación de datos textuales con otras modalidades representa una técnica avanzada que potencia significativamente las capacidades de los modelos de NLP. Al integrar diversas fuentes de información, se logra una comprensión más profunda y contextualizada de los datos, lo que se traduce en modelos más robustos y efectivos.

Reducción de dimensionalidad con PCA y t-SNE

La reducción de dimensionalidad es una técnica esencial en el análisis de datos que busca disminuir el número de variables aleatorias bajo consideración, manteniendo al mismo tiempo la mayor parte de la información relevante. En el ámbito del procesamiento de lenguaje natural (NLP), estas técnicas permiten simplificar las representaciones de alta dimensión, facilitando la visualización y mejorando el rendimiento de los modelos de aprendizaje automático.

PCA (Análisis de Componentes Principales)

El Análisis de Componentes Principales (PCA) es una técnica lineal que transforma un conjunto de variables posiblemente correlacionadas en un nuevo conjunto de variables no correlacionadas llamadas componentes principales. Estas componentes capturan la mayor parte de la varianza presente en los datos originales. En el contexto del texto, PCA puede ser utilizado para reducir la dimensionalidad de vectores de características obtenidos mediante técnicas como TF-IDF o embeddings.

Características principales de PCA:

• Linealidad: PCA asume que las relaciones entre las variables son lineales.
• Ortogonalidad: Las componentes principales son ortogonales entre sí.
• Varianza máxima: Cada componente principal captura la máxima varianza posible bajo la restricción de ortogonalidad con las componentes anteriores.

En este ejemplo, se aplica PCA a un conjunto de documentos representados como vectores TF-IDF para reducir la dimensionalidad:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.feature_extraction.text import TfidfVectorizer

# Documentos de ejemplo
documentos = [
    "El gato se sentó en la alfombra.",
    "El perro saltó sobre la alfombra.",
    "La alfombra estaba sucia.",
    "Los gatos y los perros son animales.",
    "Me gustan los animales domésticos."
]

# Transformar los documentos a representaciones TF-IDF
vectorizador = TfidfVectorizer()
X_tfidf = vectorizador.fit_transform(documentos).toarray()

# Aplicar PCA para reducir la dimensionalidad a 2 componentes
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_tfidf)

# Visualizar los documentos en el espacio reducido
plt.figure(figsize=(8, 6))
plt.scatter(X_pca[:, 0], X_pca[:, 1])
for i, doc in enumerate(documentos):
    plt.annotate(f"Doc {i+1}", (X_pca[i, 0], X_pca[i, 1]))
plt.xlabel('Componente Principal 1')
plt.ylabel('Componente Principal 2')
plt.title('PCA aplicado a documentos')
plt.show()

Este enfoque permite visualizar relaciones entre documentos en un espacio reducido, ayudando a identificar patrones como similitudes temáticas o agrupamientos.

t-SNE (t-Distributed Stochastic Neighbor Embedding)

El t-Distributed Stochastic Neighbor Embedding (t-SNE) es una técnica no lineal utilizada principalmente para la visualización de datos de alta dimensión en espacios de 2 o 3 dimensiones. En el caso de datos de texto, t-SNE puede ayudar a explorar la estructura de vectores de características complejos como embeddings generados por modelos de lenguaje preentrenados.

Características principales de t-SNE:

• No lineal: Captura relaciones complejas y estructuras de datos no lineales.
• Preservación de la estructura local: Mantiene la proximidad de puntos similares.
• Parámetros sensibles: La configuración de parámetros como perplexity y learning_rate puede influir significativamente en los resultados.

Ejemplo de uso de t-SNE con Scikit Learn

En este ejemplo, se utiliza t-SNE para visualizar vectores generados por un modelo de embeddings preentrenado:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
from sentence_transformers import SentenceTransformer

# Frases de ejemplo
frases = [
    "Los gatos son animales domésticos.",
    "Los perros son animales leales.",
    "Me gustan los gatos y los perros.",
    "Los animales salvajes viven en la naturaleza.",
    "La naturaleza es hermosa y diversa."
]

# Generar embeddings con un modelo preentrenado
modelo = SentenceTransformer('all-MiniLM-L6-v2')
embeddings = modelo.encode(frases)

# Reducir dimensionalidad con t-SNE
tsne = TSNE(n_components=2, perplexity=3, random_state=42)
X_tsne = tsne.fit_transform(embeddings)

# Visualizar los resultados
plt.figure(figsize=(8, 6))
plt.scatter(X_tsne[:, 0], X_tsne[:, 1])
for i, frase in enumerate(frases):
    plt.annotate(f"F{i+1}", (X_tsne[i, 0], X_tsne[i, 1]))
plt.xlabel('t-SNE Dimensión 1')
plt.ylabel('t-SNE Dimensión 2')
plt.title('t-SNE aplicado a embeddings de frases')
plt.show()

Este análisis ayuda a identificar cómo las frases están relacionadas entre sí en el espacio reducido y facilita la detección de temas o similitudes conceptuales.

Integración de PCA y t-SNE en Pipelines de Scikit Learn

Integrar técnicas de reducción de dimensionalidad en pipelines permite automatizar el proceso de preprocesamiento y modelado, asegurando una transformación consistente de los datos durante el entrenamiento y la predicción. En el contexto de texto, estas técnicas pueden aplicarse para transformar representaciones vectoriales antes del modelado.

Ejemplo de pipeline que incluye PCA y t-SNE:

from sklearn.pipeline import Pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# Documentos de ejemplo
documentos = [
    "El gato se sentó en la alfombra.",
    "El perro saltó sobre la alfombra.",
    "La alfombra estaba sucia.",
    "Los gatos y los perros son animales.",
    "Me gustan los animales domésticos.",
    "Los animales salvajes viven en la naturaleza.",
    "La naturaleza es hermosa y diversa.",
    "Los perros son leales y amigables."
]

etiquetas = [0, 0, 0, 1, 1, 2, 2, 1]  # Clases de ejemplo

# División de los datos
X_train, X_test, y_train, y_test = train_test_split(documentos, etiquetas, test_size=0.2, random_state=42)

# Crear el pipeline
pipeline = Pipeline([
    ('tfidf', TfidfVectorizer()),
    ('pca', PCA(n_components=50)),
    ('classifier', RandomForestClassifier(random_state=42))
], memory = None)

# Entrenar el modelo
pipeline.fit(X_train, y_train)

# Evaluar el modelo
y_pred = pipeline.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f'Precisión del modelo: {accuracy:.2f}')

Este pipeline demuestra cómo integrar PCA en un flujo de trabajo de procesamiento de texto y modelado.

Consideraciones al aplicar técnicas de reducción de dimensionalidad

• Elección de la técnica adecuada: Mientras PCA es eficiente para capturar la varianza global de los datos, t-SNE es más efectivo para visualizar estructuras locales. La elección depende del objetivo específico.
• Escalado de datos: Antes de aplicar PCA o t-SNE, es recomendable escalar los datos para asegurar que todas las características contribuyan equitativamente a la reducción de dimensionalidad.
• Interpretabilidad: Las dimensiones resultantes de PCA son combinaciones lineales de las características originales, lo que puede facilitar su interpretación. En cambio, las dimensiones de t-SNE son menos interpretables pero útiles para la visualización.
• Tiempo de cómputo: t-SNE puede ser computacionalmente intensivo para conjuntos de datos grandes. Es aconsejable utilizarlo para subconjuntos representativos o aplicar técnicas de muestreo previo.

La reducción de dimensionalidad mediante PCA y t-SNE es una herramienta para simplificar datos complejos, mejorar la eficiencia de los modelos y facilitar la visualización de estructuras inherentes en los datos de procesamiento de lenguaje natural.