Como criar um sistema de recomendação simples em Azure AI & Machine Learning

Aprende a construir um sistema de recomendação simples com Azure AI & Machine Learning para sugerir produtos/itens a utilizadores. Este fluxo mostra desde a preparação de dados até criar um endpoint para servir recomendações, útil para personalizar vendas ou conteúdos.

Pré-requisitos

• Conta Azure com permissões para criar recursos (Azure Machine Learning Workspace).
• Azure CLI e extensão az ml instaladas, ou acesso ao Azure Machine Learning Studio.
• Python 3.8+ e pip; bibliotecas: pandas, scikit-learn, implicit (ou alternativamente Surprise).
• Conceitos básicos de filtragem colaborativa e treino de modelos.

Passo 1: Preparar e entender os dados

Explica o porquê: sistemas de recomendação colaborativos precisam de uma matriz utilizador-item com ratings ou interacções. Vamos usar um conjunto de exemplo simplificado (user_id, item_id, rating). Limpar e transformar para formatos esparsos aumenta a eficiência.

# 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)))

Passo 2: Treinar um modelo colaborativo (ALS)

Porquê: Alternating Least Squares (ALS) funciona bem para dados implícitos/escassos e é eficiente para recomendações. Usamos a biblioteca implicit para um exemplo rápido. Ajusta factors e regularização conforme os teus dados.

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)

Passo 3: Validar o modelo localmente

Porquê: avaliar precisão com métricas simples evita surpresas em produção. Usa hold-out ou cross-validation; nesta fase calcula Precision@K ou Recall@K sobre dados de teste.

def precision_at_k(model, test_sparse, train_sparse, user_index, K=5):
    # items já vistos devem 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 média para alguns utilizadores
# (exemplo simplificado; em produção usa validação adequada)

Passo 4: Empacotar o modelo para deploy no Azure Machine Learning

Porquê: para servir recomendações na cloud, regista o modelo e cria um endpoint. Exporta pesos/objetos essenciais e cria um scoring script que carrega o modelo e recebe pedidos JSON com 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]}

Passo 5: Criar e implantar um Endpoint em Azure

Explica: usa Azure Machine Learning para registar o modelo e criar um Container Image ou Managed Online Endpoint. No Studio ou com az ml, define environment com Python e dependências (implicit, scikit-learn).

# comandos de exemplo (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 o resultado

Faz uma chamada HTTP POST ao endpoint com um user_id conhecido e confirma que recebes uma lista de recomendações. Verifica também logs para latência e erros. Localmente, compara recomendações com conjunto de teste e calcula Precision@K para utilizadores amostra.

Conclusão

Acabaste de criar um fluxo completo: preparar dados, treinar um modelo ALS, validar e preparar um scoring para servir recomendações com Azure Machine Learning. Próximos passos podem incluir dados implícitos, hibridar com content-based features ou automatizar tuning de hyperparâmetros. Dica: começa com poucos utilizadores/itens para iterar rápido — qual o conjunto de dados real que queres usar?