Cómo crear featurización de texto en Python para datos: paso a paso

João Barros 04 de August de 2026 5 min de lectura

Transformar texto en features numéricas es esencial para aplicaciones de Machine Learning y análisis de datos. Este tutorial muestra cómo hacer featurización de texto en Python para datos, incluyendo limpieza sencilla, TF‑IDF, n‑grams y reducción de dimensionalidad, útil para clasificación o clustering. Vamos a explicar el porqué de cada paso y dar ejemplos concretos que funcionan en conjuntos pequeños (10–1 000 filas) y en conjuntos medianos (hasta 100 000 filas).

Prerequisitos

Python 3.8+ y pip
Bibliotecas: pandas, scikit‑learn, nltk (instalar con pip)
Conocimientos básicos de pandas y Python

Para procesamiento de texto a gran escala considera también herramientas como spaCy o soluciones distribuidas, pero para prototipos y pipelines de ingeniería de features scikit‑learn + nltk son suficientes.

Paso 1: Instalar e importar dependencias

Instala las bibliotecas necesarias e importa los módulos. Usamos nltk para tokenización y scikit‑learn para TF‑IDF y reducción de dimensionalidad. La descarga de recursos de nltk se hace una vez.

pip install pandas scikit-learn nltk

# Código Python
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.decomposition import TruncatedSVD
from sklearn.pipeline import make_pipeline
import nltk
nltk.download('punkt')

Por qué: TfidfVectorizer convierte texto a una matriz dispersa, eficiente en memoria. TruncatedSVD funciona bien sobre matrices dispersas (a diferencia de PCA).

Paso 2: Cargar y visualizar datos de texto

Carga un conjunto de datos con una columna de texto. Aquí creamos un ejemplo mínimo con frases para probar la featurización. En escenarios reales, la columna puede ser comentarios, descripción de producto o textos de reviews (ej.: 10k–100k registros).

# Ejemplo mínimo de DataFrame
data = {
    'id': [1, 2, 3, 4],
    'texto': [
        'O produto é excelente e muito rápido',
        'Entrega atrasada, mau atendimento',
        'Qualidade boa, preço razoável',
        'Produto com defeito, devolvi e reembolsaram'
    ]
}
df = pd.DataFrame(data)
print(df.head())

Verifica valores nulos, duplicados o textos demasiado cortos — esos casos suelen requerir tratamiento específico (por ejemplo, eliminar o imputar).

Paso 3: Limpieza básica de texto (normalización)

Normalizar texto reduce ruido: pasar a minúsculas, eliminar puntuación y tokens irrelevantes. Mantenemos el proceso simple para que sea fácil de adaptar. En portugués, atención a los acentos; mantuvimos caracteres acentuados en el regex para conservar el significado.

import re
from nltk.tokenize import word_tokenize

def limpar_texto(s):
    s = s.lower()
    s = re.sub(r'[^a-záâãàçéêíóôõúü0-9\s]', ' ', s)
    tokens = word_tokenize(s)
    tokens = [t for t in tokens if len(t) > 2]
    return ' '.join(tokens)

df['texto_limpo'] = df['texto'].apply(limpar_texto)
print(df[['texto','texto_limpo']])

Consejo: para conjuntos más grandes añade eliminación de stopwords (por ejemplo stop_words='portuguese' en TfidfVectorizer) y normalización más avanzada (stemming/lemmatization) si es necesario.

Paso 4: Crear features con TF‑IDF y n‑grams

TF‑IDF pondera términos por frecuencia en el documento vs frecuencia en el corpus — útil para dar menos peso a términos muy frecuentes. Los parámetros importantes incluyen ngram_range, max_df y min_df.

vectorizer = TfidfVectorizer(ngram_range=(1,2), max_df=0.8, min_df=1)
X_tfidf = vectorizer.fit_transform(df['texto_limpo'])
print('TF‑IDF shape:', X_tfidf.shape)
print('Algunas features:', vectorizer.get_feature_names_out()[:10])

Explicación de parámetros: ngram_range=(1,2) captura unigrams y bigrams; max_df=0.8 ignora términos presentes en >80% de los documentos (posible ruido); min_df=1 incluye términos que aparecen al menos 1 vez — en producción conviene usar min_df=2 o min_df=0.01 (1% del corpus) para reducir la dimensionalidad.

Paso 5: Reducir dimensionalidad con TruncatedSVD

Reducir dimensionalidad ayuda a modelos y visualizaciones. TruncatedSVD (LSA) preserva variación importante. Elige n_components según el caso: 2 para visualización, 20–100 para modelos. En conjuntos con 10k documentos es habitual usar 50–200 componentes.

n_components = 2
svd = TruncatedSVD(n_components=n_components, random_state=42)
X_reduced = svd.fit_transform(X_tfidf)
# Añadir al DataFrame para uso en modelos
for i in range(n_components):
    df[f'feature_text_{i+1}'] = X_reduced[:, i]
print(df.head())

Nota: la matriz TF‑IDF es dispersa, por eso TruncatedSVD es eficiente. Verifica el porcentaje de varianza explicada (svd.explained_variance_ratio_.sum()) para ver cuánto de la información se ha preservado.

Paso 6: Pipeline completo y reutilizable

Crear un pipeline facilita aplicar el mismo proceso a nuevos datos sin repetir código. Esto garantiza reproducibilidad — importante en producción y en tests A/B.

pipeline = make_pipeline(
    TfidfVectorizer(ngram_range=(1,2), max_df=0.8, min_df=1),
    TruncatedSVD(n_components=50, random_state=42)
)

# Entrenar pipeline y transformar
X_features = pipeline.fit_transform(df['texto_limpo'])
print('Features shape (pipeline):', X_features.shape)

Ejemplo: con 1 000 documentos y 20 000 features TF‑IDF, TruncatedSVD con 50 componentes reduce a (1000, 50) — mucho más manejable para modelos como LogisticRegression o RandomForest.

Verificar el resultado

Verifica que obtuviste una matriz numérica con dimensiones esperadas y que las features tienen sentido: inspecciona valores extremos, similitud entre registros (cosine similarity) y resaltado de componentes principales. Prueba el pipeline con un clasificador sencillo y valida por cross‑validation.

# Verificar shape y algunas filas
print('DataFrame final:\n', df.head())
print('Matriz reducida ejemplo (primeras 3 filas):\n', X_reduced[:3])

# Error común: tener muchas features vacías - ajustar min_df/max_df o eliminar stopwords

Conclusión

Has concretado la featurización de texto en Python para datos: limpieza, TF‑IDF con n‑grams y reducción de dimensionalidad. Prueba parámetros como ngram_range, min_df, max_df y n_components para tu caso; por ejemplo, en reviews con 50k registros prueba min_df=5 y n_components=100. Próximos pasos incluyen entrenar un clasificador (ej.: LogisticRegression) y medir métricas (accuracy, F1), o usar embeddings pre‑entrenados si necesitas mayor capacidad sin ingeniería manual de features. Consejo práctico: mantén el pipeline versionado para reproducir resultados en producción.