Cómo hacer clustering de clientes con Azure ML: paso a paso

João Barros 11 de October de 2026 6 min de lectura

Este tutorial muestra cómo hacer clustering de clientes en Azure AI & Machine Learning para segmentación de marketing y análisis exploratorio. Explico por qué la segmentación ayuda a personalizar campañas y cómo construir una canalización simple que preprocesa datos, entrena un modelo de clustering (KMeans) y publica un endpoint para inferencia.

Requisitos previos

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 paquetes: azure-ai-ml, pandas, scikit-learn, joblib.
Conjunto de datos de clientes (CSV) con columnas numéricas y categóricas simples.

Paso 1: Crear el workspace y configurar el entorno

Necesitamos un Azure Machine Learning workspace y un entorno Python con dependencias. Si ya tiene el workspace, continúe. En caso contrario, créelo con la CLI y configure las credenciales localmente.

# Login e seleção de subscrição
az login
az account set --subscription ""

# Criar resource group e workspace (se necessário)
az group create -n rg-ml -l westeurope
az ml workspace create -w ml-workspace -g rg-ml -l westeurope

# Criar ambiente virtual (opcional)
python -m venv .venv
source .venv/bin/activate  # ou .venv\Scripts\activate no Windows
pip install azure-ai-ml pandas scikit-learn joblib

Paso 2: Preparar y cargar los datos

Cargue el CSV de clientes, trate valores faltantes y convierta variables categóricas. Para clustering, normalizar atributos numéricos es esencial para evitar sesgos.

import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import OneHotEncoder

# Carregar dados
df = pd.read_csv('clientes.csv')

# Selecionar colunas exemplo
num_cols = ['idade','rendimento','gastos_mensais']
cat_cols = ['regiao']

# Preencher NA e transformar
df[num_cols] = df[num_cols].fillna(df[num_cols].median())
df[cat_cols] = df[cat_cols].fillna('Desconhecido')

# One-hot para categóricas
ohe = OneHotEncoder(sparse=False, handle_unknown='ignore')
cat_enc = ohe.fit_transform(df[cat_cols])
cat_df = pd.DataFrame(cat_enc, columns=ohe.get_feature_names_out(cat_cols))

# Normalizar numéricos
scaler = StandardScaler()
num_scaled = scaler.fit_transform(df[num_cols])
num_df = pd.DataFrame(num_scaled, columns=num_cols)

# Concat
X = pd.concat([num_df.reset_index(drop=True), cat_df.reset_index(drop=True)], axis=1)
X.to_csv('clientes_prepared.csv', index=False)

Paso 3: Entrenar el modelo KMeans localmente

Entrenar localmente ayuda a iterar rápido. KMeans es simple e interpretable para segmentación. Pruebe diferentes valores de k y use el método del codo ('elbow') para elegir.

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

# Carregar preparado
X = pd.read_csv('clientes_prepared.csv')

# Método do cotovelo
inertia = []
K = range(2,8)
for k in K:
    kmeans = KMeans(n_clusters=k, random_state=42)
    kmeans.fit(X)
    inertia.append(kmeans.inertia_)

# Gravar e inspecionar (pode visualizar o gráfico)
import joblib
k_opt = 4  # escolha após inspeção do cotovelo
model = KMeans(n_clusters=k_opt, random_state=42)
model.fit(X)
joblib.dump((model, scaler, ohe), 'kmeans_clientes.pkl')

Paso 4: Crear un script de scoring y empaquetar para deployment

Para publicar un endpoint en Azure ML, cree un script que cargue el modelo y reciba nuevos registros en JSON/CSV para predecir el cluster. Mantenga el código mínimo y robusto frente a errores comunes (columnas faltantes).

# scoring.py
import json
import pandas as pd
import joblib

model, scaler, ohe = joblib.load('kmeans_clientes.pkl')

def preprocess(input_df):
    # Supondo mesma lógica do treino
    num_cols = ['idade','rendimento','gastos_mensais']
    cat_cols = ['regiao']
    input_df[num_cols] = input_df[num_cols].fillna(input_df[num_cols].median())
    input_df[cat_cols] = input_df[cat_cols].fillna('Desconhecido')
    cat_enc = ohe.transform(input_df[cat_cols])
    cat_df = pd.DataFrame(cat_enc, columns=ohe.get_feature_names_out(cat_cols))
    num_scaled = scaler.transform(input_df[num_cols])
    num_df = pd.DataFrame(num_scaled, columns=num_cols)
    X = pd.concat([num_df.reset_index(drop=True), cat_df.reset_index(drop=True)], axis=1)
    return X

def predict(json_input):
    df = pd.DataFrame(json.loads(json_input))
    X = preprocess(df)
    clusters = model.predict(X)
    return json.dumps({'clusters': clusters.tolist()})

Paso 5: Publicar el modelo como endpoint en Azure Machine Learning

Use el SDK azure-ai-ml para registrar el modelo y crear un endpoint para inferencia en tiempo real. Aquí mostramos los pasos esenciales; ajuste recursos y políticas según sea necesario.

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential
from azure.ai.ml.entities import Model, ManagedOnlineEndpoint, ManagedOnlineDeployment

subscription_id = ''
resource_group = 'rg-ml'
workspace = 'ml-workspace'

mlclient = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)

# Registar o ficheiro do modelo
model = mlclient.models.create_or_update(Model(name='kmeans-clientes', path='kmeans_clientes.pkl'))

# Criar endpoint gerido
endpoint = ManagedOnlineEndpoint(name='endpoint-kmeans', auth_mode='key')
mlclient.begin_create_or_update(endpoint).result()

# Criar deployment com imagem que tenha Python e dependências (exemplo mínimo)
deployment = ManagedOnlineDeployment(
    name='deploy-v1',
    endpoint_name=endpoint.name,
    model=model,
    environment={'conda_file': 'env.yml'},
    code_configuration={'code': '.', 'scoring_script': 'scoring.py'}
)
mlclient.begin_create_or_update(deployment).result()

# Traffic split
endpoint.traffic = {'deploy-v1': 100}
mlclient.begin_create_or_update(endpoint).result()

Verificar el resultado

Pruebe el endpoint con una carga de ejemplo y confirme que recibe clusters válidos. Revise también métricas de uso y logs en Azure Machine Learning Studio para resolver errores comunes (errores de serialización, columnas faltantes).

import requests

# Obter chave e URL do endpoint via MLClient ou portal
endpoint_url = 'https:///score'
api_key = ''
headers = {'Content-Type': 'application/json', 'Authorization': f'Bearer {api_key}'}

payload = [
  {'idade': 34, 'rendimento': 25000, 'gastos_mensais': 300, 'regiao': 'Norte'}
]
resp = requests.post(endpoint_url, headers=headers, json=payload)
print(resp.text)  # deve mostrar clusters

Conclusión

Ha realizado clustering de clientes en Azure AI & Machine Learning: preparó datos, entrenó KMeans, escribió un scoring script y publicó un endpoint. Siguientes pasos: probar otros algoritmos (DBSCAN, GaussianMixture), evaluar la estabilidad de los clusters e integrar la segmentación con campañas. Consejo: pruebe siempre con casos reales y verifique que las variables usadas son relevantes para marketing.