Cómo crear un sistema de recomendación sencillo en Azure AI & Machine Learning

Aprende a construir un sistema de recomendación sencillo con Azure AI & Machine Learning para sugerir productos/ítems a usuarios. Este flujo muestra desde la preparación de datos hasta crear un endpoint para servir recomendaciones, útil para personalizar ventas o contenidos.

Prerequisitos

• Cuenta Azure con permisos para crear recursos (Azure Machine Learning Workspace).
• Azure CLI y extensión az ml instaladas, o acceso al Azure Machine Learning Studio.
• Python 3.8+ y pip; bibliotecas: pandas, scikit-learn, implicit (o alternativamente Surprise).
• Conceptos básicos de filtrado colaborativo y entrenamiento de modelos.

Paso 1: Preparar y entender los datos

Explica el porqué: los sistemas de recomendación colaborativos necesitan una matriz usuario-ítem con ratings o interacciones. Vamos a usar un conjunto de ejemplo simplificado (user_id, item_id, rating). Limpiar y transformar a formatos dispersos aumenta la eficiencia.

# exemplo mínimo de preparação em Python
import pandas as pd
from scipy.sparse import coo_matrix

# dados de exemplo
rows = [1,1,2,2,3,3]
cols = [10,11,10,12,11,13]
ratings = [5,4,4,5,2,5]
df = pd.DataFrame({'user_id': rows, 'item_id': cols, 'rating': ratings})

# mapear ids para índices contínuos
user_map = {u:i for i,u in enumerate(df['user_id'].unique())}
item_map = {i:j for j,i in enumerate(df['item_id'].unique())}

users = df['user_id'].map(user_map)
items = df['item_id'].map(item_map)

sparse = coo_matrix((df['rating'], (users, items)))

Paso 2: Entrenar un modelo colaborativo (ALS)

Por qué: Alternating Least Squares (ALS) funciona bien para datos implícitos/escasos y es eficiente para recomendaciones. Usamos la biblioteca implicit para un ejemplo rápido. Ajusta factors y regularización según tus datos.

from implicit.als import AlternatingLeastSquares
import numpy as np

# implicit trabalha com item-user matrix esparsa
item_user = sparse.tocsr().T.tocsr()
model = AlternatingLeastSquares(factors=50, regularization=0.01, iterations=20)
model.fit(item_user)

# exemplo: obter top 5 recomendações para user index 0
user_index = 0
recommendations = model.recommend(user_index, sparse.tocsr(), N=5)
print(recommendations)  # tuplos (item_index, score)

Paso 3: Validar el modelo localmente

Por qué: evaluar precisión con métricas sencillas evita sorpresas en producción. Usa hold-out o cross-validation; en esta fase calcula Precision@K o Recall@K sobre datos de prueba.

def precision_at_k(model, test_sparse, train_sparse, user_index, K=5):
    # items ya vistos deben ser ignorados
    recommended = [i for i,_ in model.recommend(user_index, train_sparse, N=K*2) if i not in train_sparse[user_index].indices]
    recommended = recommended[:K]
    relevant = set(test_sparse[user_index].indices)
    return len([i for i in recommended if i in relevant]) / K

# calcular media para algunos usuarios
# (ejemplo simplificado; en producción usa validación adecuada)

Paso 4: Empaquetar el modelo para deploy en Azure Machine Learning

Por qué: para servir recomendaciones en la nube, registra el modelo y crea un endpoint. Exporta pesos/objetos esenciales y crea un scoring script que cargue el modelo y reciba peticiones JSON con user_id.

# salvar o modelo (pickle) e map de ids
import pickle
with open('als_model.pkl','wb') as f:
    pickle.dump({'model': model, 'user_map': user_map, 'item_map': item_map}, f)

# scoring.py (esqueleto)
"""
Recebe JSON: {"user_id": 123, "k": 5}
Retorna: {"recommendations": [{"item_id": 456, "score": 0.9}, ...]}
"""
import pickle
model_bundle = None

def init():
    global model_bundle
    with open('als_model.pkl','rb') as f:
        model_bundle = pickle.load(f)

def run(request):
    payload = request.get_json()
    uid = payload.get('user_id')
    k = payload.get('k',5)
    umap = model_bundle['user_map']
    if uid not in umap:
        return {'recommendations': []}
    uidx = umap[uid]
    recs = model_bundle['model'].recommend(uidx, sparse.tocsr(), N=k)
    # converter indices para item_id original
    inv_item_map = {v:k for k,v in model_bundle['item_map'].items()}
    return {'recommendations': [{'item_id': inv_item_map[i], 'score': float(s)} for i,s in recs]}

Paso 5: Crear e implantar un Endpoint en Azure

Explica: usa Azure Machine Learning para registrar el modelo y crear un Container Image o Managed Online Endpoint. En el Studio o con az ml, define environment con Python y dependencias (implicit, scikit-learn).

# comandos de ejemplo (linha) - conceptual
# az ml model register --name recommendation-model --path ./als_model.pkl
# az ml environment create --file environment.yml
# az ml online-endpoint create -n rec-endpoint -f endpoint.yml
# az ml online-deployment create -e rec-endpoint -n blue --model recommendation-model:1 --inference-config inferenceconfig.json

Verificar el resultado

Haz una llamada HTTP POST al endpoint con un user_id conocido y confirma que recibes una lista de recomendaciones. Revisa también logs para latencia y errores. Localmente, compara recomendaciones con el conjunto de prueba y calcula Precision@K para usuarios de muestra.

Conclusión

Has creado un flujo completo: preparar datos, entrenar un modelo ALS, validar y preparar un scoring para servir recomendaciones con Azure Machine Learning. Los siguientes pasos pueden incluir datos implícitos, hibridar con features basadas en contenido o automatizar el tuning de hiperparámetros. Consejo: empieza con pocos usuarios/ítems para iterar rápido — ¿qué conjunto de datos real quieres usar?