Desarrolla un sistema de recomendación con Python y Scikit-learn

1. La Importancia de los Sistemas de Recomendación en 2026

En el paisaje digital actual, la personalización ya no es un lujo, sino una expectativa fundamental del usuario. A medida que la cantidad de información, productos y servicios disponibles en línea sigue creciendo exponencialmente, la capacidad de guiar a los usuarios hacia contenido relevante se ha convertido en un pilar estratégico para empresas de todos los sectores. Los sistemas de recomendación, impulsados por Inteligencia Artificial (IA) y Machine Learning (ML), son la columna vertebral de esta personalización, actuando como filtros inteligentes que conectan a los usuarios con lo que realmente les interesa.

Para el año 2026, la sofisticación y la integración de estos sistemas han alcanzado niveles sin precedentes. Desde plataformas de streaming que sugieren tu próxima serie favorita, hasta minoristas en línea que anticipan tu próxima compra, pasando por redes sociales que curan tu feed, los algoritmos de recomendación están omnipresentes. Su impacto es tangible: mejoran la experiencia del usuario, aumentan el tiempo de permanencia en la plataforma, impulsan las ventas y fomentan la lealtad del cliente. Empresas líderes como Amazon, Netflix y Spotify atribuyen una parte significativa de su éxito a sus avanzados motores de recomendación.

Este artículo, cortesía de Kwonsejo, te guiará a través del proceso de construcción de un sistema de recomendación robusto utilizando Python, el lenguaje de programación por excelencia para la ciencia de datos, y Scikit-learn, una de las librerías de Machine Learning más populares y accesibles. Desglosaremos los conceptos fundamentales, exploraremos los tipos principales de algoritmos y te proporcionaremos ejemplos de código prácticos para que puedas empezar a construir tus propias soluciones de personalización.

2. Tipos Fundamentales de Sistemas de Recomendación

Antes de sumergirnos en la implementación, es crucial entender los diferentes enfoques para construir un sistema de recomendación. Cada tipo tiene sus propias ventajas y desventajas, y la elección depende en gran medida de la naturaleza de tus datos y del problema que intentas resolver.

2.1. Recomendación Basada en Contenido (Content-Based Filtering)

Este enfoque se basa en la descripción de los ítems y el perfil de preferencias del usuario. Si a un usuario le ha gustado un ítem en particular, el sistema le recomendará ítems similares en función de sus características. Por ejemplo, si te gusta una película de ciencia ficción con robots, el sistema buscará otras películas de ciencia ficción que también contengan robots o temas relacionados.

Las características de los ítems pueden ser etiquetas, categorías, géneros, descripciones de texto, actores, directores, etc. Se construye un perfil del usuario a partir de los ítems que ha consumido o valorado positivamente. La similitud entre ítems y entre el perfil del usuario y los ítems se calcula utilizando métricas como la similitud del coseno.

2.2. Recomendación Colaborativa (Collaborative Filtering)

El filtrado colaborativo se basa en la idea de que si dos usuarios tienen preferencias similares en el pasado (por ejemplo, han calificado los mismos ítems de manera similar), es probable que tengan preferencias similares en el futuro. No requiere información explícita sobre las características de los ítems, sino que se centra en las interacciones usuario-ítem.

Existen dos subtipos principales:

• Basado en Usuario (User-Based): Encuentra usuarios «vecinos» (similares) al usuario objetivo y recomienda ítems que esos vecinos han disfrutado pero que el usuario objetivo aún no ha visto.
• Basado en Ítem (Item-Based): Encuentra ítems «vecinos» (similares) a los ítems que el usuario objetivo ha disfrutado, basándose en cómo otros usuarios han calificado o interactuado con ellos. Este enfoque es a menudo más escalable para grandes conjuntos de datos de usuarios.

2.3. Recomendación Híbrida

Los sistemas híbridos combinan elementos de los enfoques basados en contenido y colaborativos para mitigar las debilidades de cada uno y potenciar sus fortalezas. Por ejemplo, pueden usar filtrado colaborativo para ítems populares y filtrado basado en contenido para ítems nuevos o de nicho, o combinar las predicciones de ambos modelos.

3. Preparación de Datos: El Primer Paso Crucial

La calidad y el formato de tus datos son determinantes para el éxito de cualquier sistema de recomendación. En esta sección, simularemos un conjunto de datos simple para ilustrar cómo preparar la información para nuestros modelos.

3.1. Datos para Recomendación Basada en Contenido

Para un sistema basado en contenido, necesitamos información descriptiva de cada ítem. Imaginemos un catálogo de películas con sus géneros y descripciones.

import pandas as pd

# Datos de ejemplo para películas
peliculas_data = {
    'id_pelicula': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'titulo': [
        'Interestelar', 'Origen', 'El Caballero Oscuro', 'Pulp Fiction', 
        'Forrest Gump', 'Matrix', 'Gladiator', 'La La Land', 
        'Parasitos', 'Blade Runner 2049'
    ],
    'genero': [
        'Ciencia Ficción, Aventura', 'Ciencia Ficción, Acción', 'Acción, Crimen', 
        'Crimen, Drama', 'Drama, Romance', 'Ciencia Ficción, Acción', 
        'Acción, Drama', 'Musical, Romance', 'Drama, Thriller', 
        'Ciencia Ficción, Drama'
    ],
    'descripcion': [
        'Un equipo de exploradores viaja a través de un agujero de gusano en el espacio en un intento de asegurar la supervivencia de la humanidad.',
        'Un ladrón que roba información corporativa a través de la tecnología de compartir sueños recibe la tarea inversa de implantar una idea en la mente de un CEO.',
        'Batman se enfrenta al Joker, un genio criminal que amenaza con sumir Gotham en la anarquía.',
        'Las vidas de dos sicarios, un boxeador, la esposa de un gánster y un par de ladrones se entrelazan en cuatro historias de violencia y redención.',
        'La vida de un hombre con un coeficiente intelectual bajo que es testigo y, a veces, influye en eventos históricos clave.',
        'Un programador de computadoras descubre que la realidad es una simulación elaborada por máquinas inteligentes.',
        'Un ex general romano es traicionado y su familia asesinada por un corrupto emperador. Vuelve como gladiador para vengarse.',
        'Un pianista de jazz y una aspirante a actriz se enamoran en Los Ángeles.',
        'La familia pobre de los Kim se infiltra en la rica familia de los Park. Un incidente inesperado amenaza con destruir su nuevo y precario equilibrio.',
        'Un joven blade runner descubre un secreto enterrado que podría sumir lo que queda de la sociedad en el caos.'
    ]
}
peliculas_df = pd.DataFrame(peliculas_data)
print(peliculas_df.head())

3.2. Datos para Recomendación Colaborativa

Para el filtrado colaborativo, necesitamos datos de interacción usuario-ítem, como calificaciones o visualizaciones. Crearemos un conjunto de datos simulado de calificaciones de usuarios para las películas anteriores.

# Datos de ejemplo para calificaciones de usuarios
calificaciones_data = {
    'id_usuario': [1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6],
    'id_pelicula': [1, 2, 3, 1, 4, 5, 2, 6, 7, 3, 8, 9, 1, 5, 10, 4, 7, 9],
    'calificacion': [5, 4, 3, 4, 5, 3, 5, 4, 3, 5, 4, 3, 5, 4, 5, 3, 5, 4]
}
calificaciones_df = pd.DataFrame(calificaciones_data)
print(calificaciones_df.head())

4. Sistema de Recomendación Basado en Contenido con Scikit-learn

Ahora construiremos nuestro primer sistema de recomendación utilizando el enfoque basado en contenido. Nos centraremos en la similitud de las descripciones y géneros de las películas.

4.1. Vectorización de Texto con TF-IDF

Para que Scikit-learn pueda entender las descripciones de texto, necesitamos convertirlas en representaciones numéricas. Utilizaremos TfidfVectorizer, que calcula la frecuencia de término-frecuencia inversa de documento (TF-IDF). Esto da más peso a las palabras que son importantes en un documento pero que no aparecen con frecuencia en todos los documentos.

from sklearn.feature_extraction.text import TfidfVectorizer

# Combinar género y descripción para el contenido
peliculas_df['contenido'] = peliculas_df['genero'] + ' ' + peliculas_df['descripcion']

# Inicializar TfidfVectorizer
# stop_words='english' elimina palabras comunes como 'el', 'la', 'un', 'una' que no aportan mucho significado.
# min_df=3 significa que una palabra debe aparecer en al menos 3 documentos para ser considerada.
tfidf = TfidfVectorizer(stop_words='english', min_df=1) 

# Construir la matriz TF-IDF
tfidf_matrix = tfidf.fit_transform(peliculas_df['contenido'])

print("Forma de la matriz TF-IDF:", tfidf_matrix.shape)

4.2. Cálculo de Similitud del Coseno

Una vez que tenemos la representación numérica de cada película (la matriz TF-IDF), podemos calcular la similitud entre ellas. La similitud del coseno es una métrica común que mide el coseno del ángulo entre dos vectores. Un valor cercano a 1 indica alta similitud, mientras que un valor cercano a 0 indica baja similitud.

from sklearn.metrics.pairwise import cosine_similarity

# Calcular la similitud del coseno
cosine_sim = cosine_similarity(tfidf_matrix, tfidf_matrix)

print("Matriz de similitud del coseno (primeras 5x5):")
print(cosine_sim[:5, :5])

4.3. Función de Recomendación Basada en Contenido

Finalmente, crearemos una función que, dado el título de una película, devuelve las películas más similares basándose en la matriz de similitud del coseno.

indices = pd.Series(peliculas_df.index, index=peliculas_df['titulo']).drop_duplicates()

def get_content_based_recommendations(titulo, cosine_sim_matrix=cosine_sim, df=peliculas_df, num_recommendations=5):
    if titulo not in indices:
        return "Película no encontrada en el catálogo."

    idx = indices[titulo]
    sim_scores = list(enumerate(cosine_sim_matrix[idx]))
    sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
    
    # Excluir la película de entrada
    sim_scores = [score for score in sim_scores if score[0] != idx]
    
    # Obtener los índices de las películas recomendadas
    movie_indices = [i[0] for i in sim_scores[0:num_recommendations]]
    
    return df['titulo'].iloc[movie_indices].tolist()

# Ejemplo de uso
print("Recomendaciones para 'Interestelar':")
print(get_content_based_recommendations('Interestelar'))

print("\nRecomendaciones para 'Gladiator':")
print(get_content_based_recommendations('Gladiator'))

Observa cómo las recomendaciones para ‘Interestelar’ (Ciencia Ficción, Aventura) tienden a ser otras películas de ciencia ficción como ‘Matrix’ y ‘Blade Runner 2049’. De manera similar, ‘Gladiator’ (Acción, Drama) podría recomendar ‘El Caballero Oscuro’, que comparte géneros de acción y drama.

5. Sistema de Recomendación Colaborativo Simplificado (Basado en Ítems)

Para implementar un sistema colaborativo con Scikit-learn, nos centraremos en el filtrado colaborativo basado en ítems. Esto implica encontrar ítems similares basándose en cómo los usuarios los han calificado o interactuado con ellos. La idea es que si a un usuario le gusta el ítem A, y el ítem A es muy similar al ítem B (porque muchos otros usuarios que gustaron A también gustaron B), entonces se recomienda B al usuario.

5.1. Construcción de la Matriz Usuario-Ítem

El primer paso es transformar nuestros datos de calificaciones en una matriz usuario-ítem, donde las filas son usuarios, las columnas son ítems y los valores son las calificaciones (o interacciones). Los valores NaN (Not a Number) indican que un usuario no ha calificado un ítem.

# Crear la matriz usuario-ítem
user_item_matrix = calificaciones_df.pivot_table(index='id_usuario', columns='id_pelicula', values='calificacion')

# Rellenar NaN con 0 para los cálculos de similitud, o dejar NaN para otros algoritmos
# Para nuestro propósito de similitud de ítems, rellenaremos con 0 para tratar la ausencia como no-preferencia.
user_item_matrix_filled = user_item_matrix.fillna(0)

# Asegurarse de que las columnas de la matriz user_item_matrix_filled coinciden con id_pelicula en peliculas_df
# Esto es importante para alinear la similitud de ítems con los títulos de las películas.
# Si hay películas en peliculas_df que no están en calificaciones_df, no aparecerán aquí.
# Para este ejemplo, asumiremos que todas las películas calificadas tienen una entrada en peliculas_df.
# Si no fuera así, habría que filtrar o ajustar.

# Obtener una lista ordenada de id_pelicula de la matriz para mapeo posterior
# Esto nos asegura que el orden de las columnas en user_item_matrix_filled corresponde al id_pelicula.
item_ids_in_matrix = user_item_matrix_filled.columns.tolist()

print("Matriz Usuario-Ítem (primeras 5 filas, 5 columnas):")
print(user_item_matrix_filled.iloc[:5, :5])

5.2. Cálculo de Similitud de Ítems

Ahora, calcularemos la similitud entre las películas basándonos en cómo los usuarios las han calificado. Para ello, transpondremos la matriz usuario-ítem para obtener una matriz ítem-usuario, y luego aplicaremos la similitud del coseno.

# Transponer la matriz para calcular la similitud entre ítems
item_user_matrix = user_item_matrix_filled.T

# Calcular la similitud del coseno entre ítems
item_similarity_matrix = cosine_similarity(item_user_matrix)

# Convertir a DataFrame para facilitar el acceso
item_similarity_df = pd.DataFrame(item_similarity_matrix, index=item_user_matrix.index, columns=item_user_matrix.index)

print("Matriz de similitud de ítems (primeras 5x5):")
print(item_similarity_df.iloc[:5, :5])

5.3. Función de Recomendación Colaborativa Basada en Ítems

Con la matriz de similitud de ítems, podemos crear una función que recomiende películas a un usuario. La idea es tomar las películas que un usuario ya ha calificado positivamente, encontrar ítems similares a ellas, y recomendar los ítems similares que el usuario aún no ha visto.

def get_item_based_recommendations(user_id, item_sim_df=item_similarity_df, user_ratings_df=calificaciones_df, movies_df=peliculas_df, num_recommendations=5):
    # Obtener las películas que el usuario ya ha calificado
    user_rated_movies = user_ratings_df[user_ratings_df['id_usuario'] == user_id]
    
    if user_rated_movies.empty:
        return "El usuario no ha calificado ninguna película."

    # Obtener los IDs de las películas que el usuario ha calificado
    rated_movie_ids = user_rated_movies['id_pelicula'].tolist()

    # Calcular las puntuaciones de recomendación sumando las similitudes de los ítems calificados
    recommendation_scores = {}
    for movie_id in rated_movie_ids:
        if movie_id in item_sim_df.index: # Asegurarse de que el ID de la película existe en la matriz de similitud
            sim_scores = item_sim_df[movie_id]
            for item_id, score in sim_scores.items():
                if item_id not in rated_movie_ids: # No recomendar películas ya calificadas
                    if item_id not in recommendation_scores:
                        recommendation_scores[item_id] = 0
                    recommendation_scores[item_id] += score * user_rated_movies[user_rated_movies['id_pelicula'] == movie_id]['calificacion'].iloc[0] # Ponderar por la calificación del usuario

    # Ordenar las recomendaciones por puntuación
    recommended_movies = sorted(recommendation_scores.items(), key=lambda x: x[1], reverse=True)
    
    # Obtener los títulos de las películas recomendadas
    top_recommendations = []
    for movie_id, score in recommended_movies[:num_recommendations]:
        movie_title = movies_df[movies_df['id_pelicula'] == movie_id]['titulo'].iloc[0]
        top_recommendations.append(movie_title)
            
    return top_recommendations

# Ejemplo de uso
print("\nRecomendaciones colaborativas para el usuario 1:")
print(get_item_based_recommendations(user_id=1))

print("\nRecomendaciones colaborativas para el usuario 4:")
print(get_item_based_recommendations(user_id=4))

Este enfoque colaborativo permite descubrir ítems que pueden no ser directamente similares en contenido, pero que son apreciados por usuarios con gustos similares. Por ejemplo, el Usuario 1 calificó ‘Interestelar’ (5), ‘Origen’ (4) y ‘El Caballero Oscuro’ (3). Las recomendaciones podrían incluir otras películas de acción/ciencia ficción que otros usuarios con gustos similares también disfrutaron.

6. Evaluación y Métricas de Rendimiento

Construir un sistema de recomendación es solo una parte del desafío; medir su eficacia es igualmente importante. Sin una evaluación adecuada, no podemos saber si nuestro sistema está realmente agregando valor. Las métricas de evaluación se dividen generalmente en dos categorías: precisión de predicción (para sistemas que predicen calificaciones) y precisión de ranking (para sistemas que generan listas de recomendaciones).

6.1. Métricas de Precisión de Ranking

Para sistemas que generan una lista de K recomendaciones, las métricas más comunes son:

• Precisión@K (Precision@K): Proporción de ítems relevantes en las K recomendaciones principales. Si recomiendas 5 películas y 3 de ellas realmente gustaron al usuario, tu precisión@5 es 3/5 = 0.6.
• Recall@K (Recall@K): Proporción de ítems relevantes totales que fueron incluidos en las K recomendaciones principales. Si hay 10 películas que al usuario le gustarían y recomiendas 5, de las cuales 3 son relevantes, tu recall@5 es 3/10 = 0.3.
• F1-score@K: La media armónica de precisión y recall, útil cuando se busca un equilibrio entre ambos.
• MAP (Mean Average Precision): Una métrica más sofisticada que considera el orden de las recomendaciones.
• NDCG (Normalized Discounted Cumulative Gain): Mide la calidad del ranking considerando la posición de los ítems relevantes y su grado de relevancia.

Para calcular estas métricas, generalmente dividimos nuestros datos en un conjunto de entrenamiento y un conjunto de prueba. Entrenamos el modelo con el conjunto de entrenamiento y luego generamos recomendaciones para los usuarios en el conjunto de prueba, comparándolas con los ítems que esos usuarios realmente interactuaron o calificaron positivamente en el conjunto de prueba.

6.2. Métricas de Precisión de Predicción

Si tu sistema predice calificaciones numéricas (ej. de 1 a 5 estrellas), puedes usar métricas como:

• MAE (Mean Absolute Error): El promedio de los valores absolutos de los errores de predicción.
• RMSE (Root Mean Square Error): La raíz cuadrada del promedio de los errores al cuadrado. Penetra más los errores grandes que el MAE.

from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, mean_squared_error
import numpy as np

# Ejemplo conceptual: Simular predicciones y valores reales
# En un sistema real, 'y_pred' serían las calificaciones predichas por tu modelo.
y_true = np.array([5, 4, 3, 5, 2, 4])
y_pred = np.array([4.8, 3.9, 3.2, 4.5, 2.5, 4.1])

mae = mean_absolute_error(y_true, y_pred)
rmse = np.sqrt(mean_squared_error(y_true, y_pred))

print(f"MAE (Error Absoluto Medio): {mae:.2f}")
print(f"RMSE (Error Cuadrático Medio): {rmse:.2f}")

La elección de las métricas adecuadas depende de los objetivos de tu sistema. Si el objetivo principal es que los usuarios encuentren ítems relevantes en una lista, las métricas de ranking son más apropiadas. Si se busca predecir con precisión la satisfacción del usuario con un ítem, las métricas de predicción de calificación son más relevantes.

7. Desafíos Comunes y Estrategias de Solución

A pesar de su poder, los sistemas de recomendación enfrentan varios desafíos inherentes. Comprenderlos y conocer estrategias para mitigarlos es crucial para construir sistemas robustos y efectivos.

7.1. Problema del «Cold Start»

Este es uno de los mayores desafíos. Se refiere a la dificultad de hacer recomendaciones para:

• Nuevos usuarios: No hay historial de interacciones para construir un perfil.
• Nuevos ítems: No hay suficientes interacciones de usuarios para calcular la similitud colaborativa.

7.2. Escasez de Datos (Data Sparsity)

En muchos datasets de recomendación, la mayoría de los usuarios solo interactúan con un pequeño subconjunto de ítems disponibles. Esto resulta en matrices usuario-ítem con una gran cantidad de valores nulos (escasas), lo que dificulta el cálculo de similitudes precisas.

7.3. Sesgo y Equidad

Los sistemas de recomendación pueden heredar y amplificar sesgos presentes en los datos de entrenamiento. Esto puede llevar a la «cámara de eco» (recomendar solo lo que ya se sabe que le gusta al usuario) o a la exclusión de ciertos ítems o grupos de usuarios.

8. Aplicaciones Prácticas y Casos de Uso Empresariales

Los sistemas de recomendación son herramientas increíblemente versátiles con aplicaciones en casi todos los sectores que manejan grandes volúmenes de datos y usuarios. En 2026, su implementación es una ventaja competitiva clave.

8.1. Comercio Electrónico y Retail

Este es quizás el caso de uso más conocido. Plataformas como Amazon y Alibaba utilizan sistemas de recomendación para sugerir productos basados en el historial de compras, el comportamiento de navegación, los artículos vistos por otros usuarios y las características del producto. Se estima que las recomendaciones son responsables de un aumento de hasta el 30-40% en las ventas de comercio electrónico en algunos casos.

8.2. Plataformas de Streaming de Contenido

Netflix, Spotify, YouTube y otras plataformas dependen en gran medida de los sistemas de recomendación para mantener a los usuarios comprometidos. Sugieren películas, series, música o videos basándose en el historial de visualización/escucha, géneros preferidos, artistas, directores y el comportamiento de usuarios similares. Esto no solo mejora la satisfacción del usuario, sino que también aumenta el tiempo de permanencia en la plataforma y reduce la tasa de abandono.

8.3. Redes Sociales y Noticias

Facebook, Instagram, Twitter y LinkedIn utilizan recomendaciones para personalizar los feeds de noticias, sugerir amigos, grupos, publicaciones o conexiones. Los sitios de noticias recomiendan artículos basados en los intereses de lectura previos del usuario, aumentando el consumo de contenido y la relevancia percibida.

8.4. Educación y Salud

Incluso en sectores más tradicionales, los sistemas de recomendación están encontrando su nicho. En educación, pueden sugerir cursos, materiales de estudio o rutas de aprendizaje personalizadas. En salud, pueden recomendar planes de dieta, ejercicios o artículos de salud basados en el perfil del paciente y sus objetivos.

Preguntas Frecuentes

Q. ¿Cuál es la principal diferencia entre un sistema de recomendación basado en contenido y uno colaborativo?

La diferencia clave radica en la fuente de información. El basado en contenido recomienda ítems similares a los que le gustaron al usuario, basándose en sus características. El colaborativo recomienda ítems que les gustaron a usuarios con gustos similares, sin necesidad de conocer las características del ítem.

Q. ¿Scikit-learn es adecuado para construir sistemas de recomendación a gran escala?

Scikit-learn es excelente para prototipos y sistemas de tamaño mediano, especialmente para enfoques basados en contenido y filtrado colaborativo basado en vecinos. Para sistemas a gran escala con millones de usuarios e ítems, donde la escasez de datos y el rendimiento son críticos, podrías necesitar librerías más especializadas como Surprise, o frameworks distribuidos como Spark MLlib.

Q. ¿Cómo se maneja el problema del «cold start» para nuevos usuarios o ítems?

Para nuevos usuarios, se suelen recomendar ítems populares, de tendencia, o se les pide que califiquen algunos ítems iniciales. Para nuevos ítems, los sistemas basados en contenido son efectivos, ya que pueden usar las descripciones del ítem para hacer recomendaciones desde el principio. Los sistemas híbridos son una solución robusta para ambos casos.

Q. ¿Por qué es importante la evaluación de un sistema de recomendación?

La evaluación es crucial para entender qué tan bien está funcionando el sistema y si está cumpliendo sus objetivos de negocio. Permite comparar diferentes algoritmos, identificar áreas de mejora y asegurar que las recomendaciones son realmente relevantes y útiles para los usuarios.

Q. ¿Qué es la similitud del coseno y por qué se usa en sistemas de recomendación?

La similitud del coseno es una métrica que mide el coseno del ángulo entre dos vectores en un espacio multidimensional. Se usa porque mide la similitud de orientación de dos vectores, es decir, qué tan similares son en dirección, independientemente de su magnitud. Esto es ideal para comparar perfiles de usuarios o ítems representados como vectores de características o calificaciones.

↑