Home / IA & ML / Bolsa de palabras en Python: de cero a CountVectorizer
Bolsa de palabras en Python: de cero a CountVectorizer

Bolsa de palabras en Python: de cero a CountVectorizer

17 November 2026 · 20 min de lectura ··

Por qué los modelos no entienden el texto sin una traducción numérica

Un algoritmo de aprendizaje automático solo sabe operar con números. Si le entregas la frase “el pedido llegó tarde”, no tiene forma de extraer nada útil de esas letras: necesita que alguien las convierta en una estructura numérica de tamaño fijo, con la que pueda calcular distancias, pesos y probabilidades. Esa conversión recibe el nombre de vectorización, y la técnica más sencilla y más antigua para lograrla es la bolsa de palabras, conocida en inglés como bag of words.

La idea es casi ingenua. Imagina que cada documento es una bolsa en la que lanzas todas sus palabras sin respetar el orden. Después, en lugar de leer el contenido, cuentas cuántas veces aparece cada palabra del vocabulario conocido. El resultado es un vector de números enteros: una posición por palabra, y en cada posición el número de apariciones. Dos documentos que hablan de lo mismo tenderán a producir vectores parecidos, y eso basta para tareas como clasificar correos, detectar opiniones positivas o negativas, agrupar noticias o buscar documentos similares.

En este tutorial recorreremos el camino completo. Primero construiremos la técnica a mano, con Python puro y NumPy, para que entiendas cada paso. Luego la reproduciremos con CountVectorizer de scikit-learn, veremos cómo ajustar sus parámetros, añadiremos n-gramas, hablaremos de la ponderación TF-IDF, entrenaremos un clasificador real y revisaremos errores frecuentes, rendimiento y alternativas modernas. Al final sabrás cuándo esta técnica es suficiente y cuándo conviene pasar a representaciones más ricas.

Preparación del entorno y versiones recomendadas

Para seguir los ejemplos necesitas un intérprete de Python reciente. En el momento de escribir esto, la rama estable más extendida es Python 3.14, y todo el código funciona igual en cualquier 3.10 o superior. En cuanto a librerías, usaremos scikit-learn 1.8, NumPy como dependencia de ella y NLTK, que mantiene su serie 3.10. Conviene trabajar dentro de un entorno virtual para no mezclar dependencias con las del sistema.

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
python -m pip install scikit-learn nltk numpy

Para comprobar que todo quedó bien instalado, imprime las versiones desde un pequeño script.

import sklearn
import nltk
import numpy as np

print("scikit-learn:", sklearn.__version__)
print("nltk:", nltk.__version__)
print("numpy:", np.__version__)
scikit-learn: 1.8.0
nltk: 3.10.x
numpy: 2.x

Los números exactos de la salida dependerán de lo que haya resuelto pip en tu máquina. Lo importante es que no aparezcan errores de importación. Una estructura de proyecto mínima, suficiente para este tutorial, podría ser la siguiente.

bolsa-palabras/
├── .venv/
├── bow_manual.py
├── bow_sklearn.py
└── clasificador.py

El corpus de ejemplo que usaremos en todo el tutorial

Para que los resultados sean fáciles de verificar a ojo, trabajaremos con un corpus diminuto: seis opiniones breves sobre un servicio de mensajería. Son pocas frases a propósito, porque así podrás comprobar cada vector sin herramientas adicionales.

corpus = [
    "El paquete llegó rápido y el envío fue excelente",
    "El envío llegó tarde y el paquete estaba dañado",
    "Excelente servicio, el repartidor fue muy amable",
    "Servicio pésimo, el repartidor fue grosero y tardó mucho",
    "Paquete intacto y entrega rápida, excelente servicio",
    "Entrega tardía y paquete dañado, pésimo servicio",
]

Fíjate en que hay vocabulario compartido (“paquete”, “servicio”, “envío”), palabras que se repiten dentro de una misma frase (“el” aparece dos veces en la primera) y signos de puntuación pegados a las palabras. Todo eso es lo que haremos que la técnica sepa manejar.

Los tres pasos de la técnica: limpiar, catalogar y contar

Cualquier implementación de bolsa de palabras, por simple o sofisticada que sea, hace lo mismo en tres fases.

  1. Preprocesar cada documento: dividirlo en unidades llamadas tokens, normalizar mayúsculas, quitar puntuación y descartar palabras vacías de significado.
  2. Construir el vocabulario: reunir todos los tokens distintos de todo el corpus y asignarle a cada uno una posición fija.
  3. Contar: para cada documento, crear un vector con tantas posiciones como palabras tiene el vocabulario y rellenarlo con las frecuencias.

Lo más delicado es mantener el mismo vocabulario y el mismo orden para todos los documentos. Si una posición significara “paquete” en un vector y “servicio” en otro, las comparaciones no tendrían sentido. Por eso el vocabulario se aprende una sola vez con los datos de entrenamiento y después se reutiliza como un vocabulario fijo y ordenado para todo texto nuevo.

Preprocesamiento: tokens, minúsculas y palabras vacías

El primer paso es convertir una cadena en una lista de palabras limpias. Si quieres profundizar en las distintas estrategias para dividir texto, tienes una explicación detallada en cómo tokenizar texto en Python. Aquí nos basta con una expresión regular que capture secuencias de letras, incluidas las acentuadas y la eñe.

Respecto a las mayúsculas, “Servicio” y “servicio” deben contarse como la misma palabra. Para el español, el método lower() suele bastar, aunque en idiomas con reglas especiales existe casefold(); la diferencia se analiza en minúsculas en Python con lower y casefold.

Las palabras vacías, o stopwords, son términos muy frecuentes que aportan poca información para distinguir un documento de otro: artículos, preposiciones, conjunciones. Podemos definir una lista propia o tomar la que ofrece NLTK para español. La primera vez que uses NLTK debes descargar el recurso.

import nltk

nltk.download("stopwords")
[nltk_data] Downloading package stopwords to /home/usuario/nltk_data...
[nltk_data]   Unzipping corpora/stopwords.zip.

Con el recurso disponible, escribimos la función de preprocesamiento.

import re
from nltk.corpus import stopwords

PALABRAS_VACIAS = set(stopwords.words("spanish"))
PATRON = re.compile(r"[a-záéíóúüñ]+")


def preprocesar(texto: str) -> list[str]:
    texto = texto.lower()
    tokens = PATRON.findall(texto)
    return [t for t in tokens if t not in PALABRAS_VACIAS]


print(preprocesar("El paquete llegó rápido y el envío fue excelente"))
['paquete', 'llegó', 'rápido', 'envío', 'excelente']

Observa que desaparecieron “el”, “y” y “fue”, y que la coma o el punto ya no estorban. Una advertencia importante: la lista de NLTK para español puede incluir palabras como “no” o “muy”, que en análisis de opiniones cambian el sentido de la frase. Más adelante volveremos sobre este riesgo.

Construcción del vocabulario ordenado

Con los documentos convertidos en listas de tokens, el vocabulario es simplemente el conjunto de todos los tokens, sin repetidos, en un orden estable. Ordenarlos alfabéticamente garantiza que el resultado sea reproducible entre ejecuciones.

def construir_vocabulario(documentos: list[str]) -> list[str]:
    palabras = set()
    for doc in documentos:
        palabras.update(preprocesar(doc))
    return sorted(palabras)


vocabulario = construir_vocabulario(corpus)
print(len(vocabulario))
print(vocabulario)
19
['amable', 'dañado', 'entrega', 'envío', 'estaba', 'excelente', 'grosero', 'intacto', 'llegó', 'mucho', 'paquete', 'pésimo', 'rápida', 'rápido', 'repartidor', 'servicio', 'tarde', 'tardó']

Esta salida es orientativa: el orden depende de las reglas de comparación de cadenas, y los números exactos pueden variar según el contenido de la lista de palabras vacías de tu versión de NLTK. No te obsesiones con reproducir la salida carácter por carácter; fíjate en el mecanismo. Cada token recibe un índice que será su columna en la matriz final.

Un detalle de diseño útil es guardar el vocabulario como un diccionario de palabra a índice. Buscar en una lista es lineal, mientras que un diccionario responde en tiempo constante, y esto marca la diferencia cuando el vocabulario tiene decenas de miles de entradas.

indice = {palabra: pos for pos, palabra in enumerate(vocabulario)}
print(indice["paquete"])

Generación de vectores con NumPy

Ahora convertimos cada documento en su vector de frecuencias. Partimos de un arreglo de ceros del tamaño del vocabulario y sumamos uno en la posición de cada token que encontremos. Si una palabra se repite, su casilla crece, y así se conserva la información de cuántas veces aparece.

import numpy as np


def vectorizar(documento: str, indice: dict[str, int]) -> np.ndarray:
    vector = np.zeros(len(indice), dtype=int)
    for token in preprocesar(documento):
        if token in indice:
            vector[indice[token]] += 1
    return vector


matriz = np.array([vectorizar(doc, indice) for doc in corpus])
print(matriz.shape)
print(matriz[0])
(6, 19)
[0 0 0 1 0 1 0 0 1 0 1 0 0 1 0 0 0 0 0]

La matriz resultante tiene una fila por documento y una columna por palabra del vocabulario. La condición if token in indice es lo que permite, más adelante, vectorizar textos nuevos que contengan palabras desconocidas: simplemente se ignoran, porque el modelo no sabe qué hacer con ellas.

Este es el momento de interiorizar una propiedad esencial. Dos frases con las mismas palabras en distinto orden producen exactamente el mismo vector. “El perro mordió al cartero” y “El cartero mordió al perro” son indistinguibles para esta representación, y esa pérdida es el precio de su simplicidad.

Comparar documentos: similitud del coseno sobre los vectores

Una vez que los documentos son vectores, puedes medir cuánto se parecen. La medida más habitual es la similitud del coseno, que calcula el ángulo entre dos vectores y se ve poco afectada por la longitud del documento.

def coseno(a: np.ndarray, b: np.ndarray) -> float:
    norma = np.linalg.norm(a) * np.linalg.norm(b)
    return float(a @ b / norma) if norma else 0.0


print(round(coseno(matriz[0], matriz[1]), 3))
print(round(coseno(matriz[0], matriz[3]), 3))
0.333
0.0

Los valores van de 0 a 1 en este caso, porque las frecuencias nunca son negativas. Una similitud de 0 indica que los documentos no comparten ninguna palabra del vocabulario. Este cálculo es la base de muchos buscadores sencillos y recomendadores de contenido.

La misma tarea con CountVectorizer de scikit-learn

Escribir todo esto a mano es excelente para aprender, pero en proyectos reales usarás la clase CountVectorizer, que encapsula el preprocesamiento, el vocabulario y el conteo, y devuelve una matriz dispersa eficiente en memoria.

from sklearn.feature_extraction.text import CountVectorizer

vectorizador = CountVectorizer()
matriz = vectorizador.fit_transform(corpus)

print(matriz.shape)
print(vectorizador.get_feature_names_out())
print(matriz.toarray()[0])
(6, 22)
['amable' 'dañado' 'entrega' 'envío' 'estaba' 'excelente' 'grosero'
 'intacto' 'llegó' 'mucho' 'muy' 'paquete' 'pésimo' 'rápida' 'rápido'
 'repartidor' 'servicio' 'tarde' 'tardó' 'tardía' 'el' 'fue']

El método fit_transform hace dos cosas en una sola llamada: aprende el vocabulario con fit y genera la matriz con transform. Los nombres de las columnas se obtienen con get_feature_names_out(), que sustituyó al antiguo get_feature_names(), eliminado en versiones recientes. Si encuentras tutoriales antiguos con ese método, adáptalos a la forma actual.

Algo que sorprende a muchos: sin configurar nada, aparecen palabras como “el” o “fue”, y el listado puede diferir del de nuestra versión manual. La razón es que CountVectorizer no elimina palabras vacías por defecto, y su patrón de tokens por omisión descarta las palabras de una sola letra, por lo que la “y” desaparece sin que lo hayas pedido. Veamos cómo controlar todo eso.

Parámetros que cambian el resultado

La clase ofrece muchos parámetros, pero unos pocos resuelven el noventa por ciento de los casos.

El parámetro lowercase está activado de forma predeterminada, así que el paso de minúsculas ya viene incluido. Con stop_words puedes pasar una lista propia. Ojo: el valor especial "english" solo existe para inglés, y para español debes aportar tú la lista.

from nltk.corpus import stopwords

vectorizador = CountVectorizer(
    stop_words=stopwords.words("spanish"),
    token_pattern=r"(?u)\b[^\W\d_]{2,}\b",
)
matriz = vectorizador.fit_transform(corpus)
print(matriz.shape)

El parámetro token_pattern define qué es un token. Cambiarlo permite, por ejemplo, conservar palabras de una letra o excluir números. Con min_df descartas términos demasiado raros, que aparecen en pocos documentos y suelen ser ruido o erratas; con max_df eliminas los que aparecen en casi todos y por tanto no distinguen nada. Con max_features te quedas solo con las más frecuentes, lo que acota el tamaño del vocabulario.

vectorizador = CountVectorizer(
    stop_words=stopwords.words("spanish"),
    min_df=2,
    max_df=0.9,
    max_features=1000,
)

Puedes expresar min_df y max_df como enteros, que cuentan documentos, o como decimales entre 0 y 1, que representan proporciones del corpus. Si te interesa solo saber si una palabra aparece o no, sin importar cuántas veces, activa binary=True: la matriz contendrá únicamente ceros y unos.

Un consejo de uso: guarda los nombres de los parámetros en una variable de configuración y no los repartas por el código. Cuando compares experimentos, necesitarás saber exactamente qué ajustes produjeron cada resultado.

Estructura de la matriz dispersa y por qué importa

El resultado de fit_transform no es un arreglo normal, sino una matriz dispersa en formato CSR. En un corpus real, cada documento contiene unas pocas decenas de palabras distintas, pero el vocabulario puede tener cien mil. Más del 99 por ciento de las celdas valen cero, y almacenarlas sería un despilfarro de memoria.

print(type(matriz))
print("elementos no nulos:", matriz.nnz)
densidad = matriz.nnz / (matriz.shape[0] * matriz.shape[1])
print(f"densidad: {densidad:.2%}")
<class 'scipy.sparse._csr.csr_matrix'>
elementos no nulos: 22
densidad: 25.00%

La matriz dispersa guarda solo los valores distintos de cero y sus posiciones. Cuando llamas a toarray() conviertes todo a formato denso, lo cual es práctico para inspeccionar ejemplos pequeños pero peligroso con datos grandes: una matriz de cien mil documentos por cien mil palabras ocuparía decenas de gigabytes. Por eso conviene mantener la forma dispersa y pasar esa estructura directamente a los modelos de scikit-learn, que la aceptan sin problemas.

Más contexto con n-gramas

La principal debilidad de la técnica es ignorar el orden. Una forma barata de recuperar algo de contexto es contar secuencias de palabras consecutivas, llamadas n-gramas, en lugar de palabras sueltas. Un bigrama es un par de palabras seguidas; un trigrama, tres.

Considera la expresión “no recomendable”. Con unigramas, “no” y “recomendable” se cuentan por separado y el modelo puede asociar “recomendable” con una opinión positiva. Con bigramas aparece la característica “no recomendable”, que sí transmite el sentido real. El parámetro ngram_range controla esto.

vectorizador = CountVectorizer(ngram_range=(1, 2))
matriz = vectorizador.fit_transform(corpus)
print(matriz.shape)
print(vectorizador.get_feature_names_out()[:8])
(6, 55)
['amable' 'dañado' 'el' 'el envío' 'el paquete' 'el repartidor' 'entrega' 'entrega rápida']

La tupla (1, 2) significa que se generan tanto unigramas como bigramas. El coste es evidente: el vocabulario crece de forma muy rápida, porque el número de combinaciones posibles es enorme. En la práctica conviene acompañar los n-gramas con min_df o max_features, de modo que solo sobrevivan las combinaciones que se repiten lo suficiente como para ser útiles.

Existe también una variante por caracteres. Con analyzer="char_wb" y un rango como (3, 5) se cuentan fragmentos de letras dentro de cada palabra. Es una opción valiosa para textos con faltas de ortografía, idiomas con mucha morfología o nombres propios, porque “entregado” y “entregaron” comparten buena parte de sus fragmentos.

Pesar los términos con TF-IDF

El conteo bruto tiene un problema: las palabras muy comunes dominan los vectores, aunque no digan nada sobre el tema del documento. TF-IDF corrige esto multiplicando la frecuencia del término en el documento por un factor que decrece cuanto más documentos del corpus contienen esa palabra. En resumen, premia las palabras frecuentes en un documento pero raras en el conjunto.

Scikit-learn lo ofrece en dos formas equivalentes: TfidfVectorizer hace todo de una vez, y TfidfTransformer se aplica sobre una matriz de conteos ya calculada.

from sklearn.feature_extraction.text import TfidfVectorizer

tfidf = TfidfVectorizer(stop_words=stopwords.words("spanish"))
pesos = tfidf.fit_transform(corpus)

fila = pesos[0].toarray()[0]
nombres = tfidf.get_feature_names_out()
for nombre, peso in sorted(zip(nombres, fila), key=lambda x: -x[1])[:4]:
    if peso > 0:
        print(f"{nombre}: {peso:.3f}")
llegó: 0.467
rápido: 0.467
envío: 0.389
paquete: 0.389

Por defecto, cada fila se normaliza para tener norma euclídea igual a 1, lo cual facilita las comparaciones entre documentos de distinta longitud. Si trabajas con búsqueda o recomendación de textos, TF-IDF suele superar al conteo simple casi sin esfuerzo adicional. Para clasificación, conviene probar ambas variantes con validación cruzada, porque el resultado depende del problema.

Un clasificador de opiniones de principio a fin

Veamos la utilidad práctica de todo lo anterior. Usaremos la bolsa de palabras como primera etapa de un modelo que decide si una opinión es positiva o negativa. La mejor forma de encadenar la vectorización y el modelo es un Pipeline, que garantiza que el vocabulario se aprenda únicamente con los datos de entrenamiento.

from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

opiniones = [
    "Excelente servicio y entrega rápida",
    "El repartidor fue amable y el paquete llegó intacto",
    "Muy buen envío, todo perfecto",
    "Recomendable por su rapidez y atención",
    "Servicio pésimo, el paquete llegó dañado",
    "Entrega tardía y repartidor grosero",
    "Nada recomendable, tardaron una semana",
    "Un desastre, perdieron mi envío",
    "Atención amable y entrega rápida",
    "Paquete dañado y servicio terrible",
]
etiquetas = [1, 1, 1, 1, 0, 0, 0, 0, 1, 0]

x_train, x_test, y_train, y_test = train_test_split(
    opiniones, etiquetas, test_size=0.3, random_state=7, stratify=etiquetas
)

modelo = make_pipeline(
    CountVectorizer(ngram_range=(1, 2)),
    LogisticRegression(max_iter=1000),
)
modelo.fit(x_train, y_train)

print("precisión:", modelo.score(x_test, y_test))
print(modelo.predict(["El paquete llegó rápido y en perfecto estado"]))
precisión: 0.6666666666666666
[1]

Con tan pocos ejemplos, los números no son concluyentes, y no pretenden serlo: sirven para ver la estructura del flujo. Con un conjunto real de miles de opiniones, este esquema ofrece una línea base sólida y rápida de entrenar. Un detalle crucial es que el método predict aplica internamente transform, no fit_transform, de manera que las palabras nuevas se ignoran en lugar de alterar el vocabulario.

Para entender qué aprendió el modelo, puedes mirar los coeficientes asociados a cada palabra. Los más positivos apuntan a opiniones favorables y los más negativos a críticas.

vec = modelo.named_steps["countvectorizer"]
clf = modelo.named_steps["logisticregression"]

pares = sorted(zip(clf.coef_[0], vec.get_feature_names_out()))
print("negativas:", [p for _, p in pares[:3]])
print("positivas:", [p for _, p in pares[-3:]])

Esta interpretabilidad es una de las grandes ventajas de la técnica frente a los modelos neuronales: puedes explicar por qué el sistema tomó una decisión señalando las palabras que más pesaron.

Fuga de datos: el error más caro y más silencioso

El fallo más habitual al empezar es ajustar el vectorizador con todo el conjunto de datos antes de dividirlo en entrenamiento y prueba, y eso contamina la evaluación. Parece inocente, pero hace que el vocabulario, y en TF-IDF también las frecuencias de documentos, incorporen información de los datos de prueba. Las métricas salen infladas y luego el modelo decepciona en producción.

# Incorrecto: el vocabulario ya conoce los datos de prueba
vectorizador = CountVectorizer()
x_todo = vectorizador.fit_transform(opiniones)
x_train, x_test = train_test_split(x_todo, test_size=0.3)

# Correcto: aprender solo con entrenamiento
vectorizador = CountVectorizer()
x_train = vectorizador.fit_transform(textos_entrenamiento)
x_test = vectorizador.transform(textos_prueba)

La regla es simple: fit solo con entrenamiento, transform con todo lo demás. Usar un Pipeline evita el error por construcción, incluso dentro de la validación cruzada, donde cada partición vuelve a aprender su propio vocabulario.

Errores comunes y cómo evitarlos

Además de la fuga de datos, hay otros tropiezos que se repiten una y otra vez.

  • Quitar negaciones. Listas de palabras vacías demasiado agresivas eliminan “no”, “ni” o “sin”. En análisis de opiniones, esto convierte “no me gustó” en “gustó”. Revisa la lista y retira las negaciones, o usa bigramas.
  • Olvidar la normalización de acentos. “Rápido” y “rapido” son tokens distintos. En textos de redes sociales, donde se escribe sin tildes, puedes usar strip_accents="unicode" para unificarlos.
  • Convertir a denso sin necesidad. Llamar a toarray() sobre una matriz grande agota la memoria. Mantén la forma dispersa.
  • Usar un vocabulario enorme sin filtrar. Sin min_df, cada errata y cada nombre propio ocupa una columna que casi nunca aporta señal.
  • No guardar el vectorizador. Si entrenas un modelo y olvidas persistir el vectorizador ajustado, no podrás procesar texto nuevo con el mismo vocabulario. Guarda ambos juntos, por ejemplo con joblib.
import joblib

joblib.dump(modelo, "clasificador_opiniones.joblib")
cargado = joblib.load("clasificador_opiniones.joblib")
print(cargado.predict(["Servicio terrible y paquete dañado"]))
[0]

Guardar el Pipeline completo resuelve el problema, porque el vocabulario viaja dentro del mismo archivo que el modelo. Eso sí, carga únicamente archivos de origen confiable, ya que este formato puede ejecutar código al deserializarse.

Rendimiento y memoria con corpus grandes

Cuando el corpus crece, el cuello de botella suele ser el vocabulario. CountVectorizer mantiene en memoria un diccionario de todas las palabras vistas, y con millones de documentos esto puede ser costoso. Hay tres estrategias para mantenerlo bajo control.

La primera es filtrar con min_df y max_features, descartando lo raro. La segunda es usar HashingVectorizer, que no almacena vocabulario: aplica una función hash para decidir la columna de cada palabra, de modo que el tamaño de la matriz es fijo y la memoria no crece con el corpus.

from sklearn.feature_extraction.text import HashingVectorizer

hashing = HashingVectorizer(n_features=2**18, alternate_sign=False)
x = hashing.transform(corpus)
print(x.shape)
(6, 262144)

El inconveniente es que no puedes recuperar qué palabra corresponde a cada columna, y dos palabras distintas pueden colisionar en la misma casilla. La tercera estrategia es procesar por lotes con partial_fit en modelos compatibles, vectorizando cada bloque con el hashing y actualizando el clasificador poco a poco, de forma que nunca necesites cargar todo el corpus a la vez.

Otro punto de rendimiento es el propio preprocesamiento. Si pasas a CountVectorizer un analizador escrito en Python que lematiza o consulta recursos externos, el tiempo se disparará. Mide antes de optimizar: con time.perf_counter y una muestra representativa descubrirás si el problema está en el tokenizador o en el modelo.

Limitaciones reales de la técnica

Conviene ser honesto con lo que la bolsa de palabras no puede hacer.

No capta el significado. Una misma palabra puede tener sentidos distintos según el contexto: “banco” como asiento o como entidad financiera genera la misma columna. Y dos palabras sinónimas, como “rápido” y “veloz”, ocupan columnas independientes sin ninguna relación entre ellas, de modo que el modelo debe aprender cada una por separado y necesita más datos para hacerlo.

Tampoco entiende el orden ni la estructura gramatical. Las frases con ironía, negaciones complejas o dependencias a larga distancia suelen confundirla. Además, genera vectores de gran dimensión y muy dispersos, lo cual complica el entrenamiento de algunos algoritmos y favorece el sobreajuste cuando hay pocos ejemplos y muchas características.

Por último, está el problema de las palabras fuera del vocabulario. Todo lo que no se vio durante el entrenamiento se descarta sin avisar, incluso si es decisivo. Un nuevo término de moda, un producto lanzado después del entrenamiento o una errata sistemática quedarán invisibles para el modelo.

Cuándo elegir bolsa de palabras y cuándo otra alternativa

Con estas limitaciones en mente, ¿para qué sigue siendo una buena elección? Para líneas base rápidas, clasificación de temas, filtrado de spam, enrutado de tickets de soporte y cualquier caso donde la presencia de ciertas palabras clave sea la señal principal. Entrena en segundos, no necesita GPU, es barata de desplegar y se puede explicar, algo que muchos equipos valoran.

Cuando el significado y el contexto importan de verdad, las alternativas mejoran el resultado. Los embeddings de palabras, como Word2Vec o GloVe, representan cada término como un vector denso donde los sinónimos quedan cerca. Los modelos basados en transformadores generan representaciones que dependen de la frase completa, resolviendo la ambigüedad de “banco”. Y los embeddings de oraciones permiten comparar textos por significado con unas pocas líneas.

La regla práctica que funciona bien es empezar siempre por una bolsa de palabras con regresión logística o un clasificador lineal similar. Si esa línea base ya cumple los requisitos, quédate con ella. Si no, tendrás una referencia contra la que medir cuánto aporta realmente el modelo más complejo, y evitarás pagar su coste de cómputo sin una mejora que lo justifique.

Un flujo de trabajo recomendado para tus proyectos

Para cerrar la parte práctica, aquí tienes una secuencia ordenada que reúne lo aprendido y reduce la posibilidad de errores.

  1. Inspecciona los datos y decide qué cuenta como token: ¿importan los números, las menciones, los emoticonos?
  2. Define el preprocesamiento mínimo necesario. Menos es más: cada transformación puede eliminar señal útil.
  3. Separa entrenamiento y prueba antes de cualquier ajuste, preferiblemente con estratificación si las clases están desbalanceadas.
  4. Construye un Pipeline con el vectorizador y un modelo lineal sencillo.
  5. Prueba unigramas frente a bigramas y conteo frente a TF-IDF con validación cruzada, en lugar de decidir por intuición.
  6. Ajusta min_df, max_df y max_features para controlar el tamaño del vocabulario.
  7. Revisa los coeficientes y los errores del modelo para detectar palabras vacías mal elegidas o clases confundidas.
  8. Guarda el pipeline completo y documenta los parámetros usados.

Un buen hábito adicional es mirar los documentos que el modelo clasifica mal. Casi siempre revelan un patrón: una negación que se perdió, un término propio del dominio que la lista de palabras vacías eliminó, o etiquetas incorrectas en los datos originales. Ese análisis de errores aporta más mejora que cambiar de algoritmo.

Conclusiones

La bolsa de palabras convierte texto en números contando apariciones de cada término de un vocabulario fijo. Su mecánica se resume en tres pasos: preprocesar, construir el vocabulario y generar vectores. Implementarla a mano con Python y NumPy te da una comprensión que ninguna librería puede sustituir, y hacerlo con CountVectorizer te lleva a producción con muy pocas líneas y una matriz dispersa eficiente.

Los parámetros stop_words, min_df, max_df, max_features y ngram_range te permiten adaptar la representación a cada problema, y TF-IDF aporta una ponderación que suele mejorar la búsqueda y la clasificación. Evita la fuga de datos ajustando el vectorizador solo con el conjunto de entrenamiento, conserva las negaciones cuando analices opiniones y guarda siempre el pipeline completo junto con el modelo.

Sus límites son claros: ignora el significado, el orden y las palabras que no vio al entrenar. Aun así, sigue siendo una línea base excelente, rápida y explicable. Empieza por ella, mide sus resultados y solo entonces decide si necesitas dar el salto a embeddings o a modelos basados en transformadores.