Como fazer clustering de clientes com Azure ML: passo a passo

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

Este tutorial mostra como fazer clustering de clientes em Azure AI & Machine Learning para segmentação de marketing e análise exploratória. Explico porque a segmentação ajuda a personalizar campanhas e como construir um pipeline simples que pré-processa dados, treina um modelo de clustering (KMeans) e publica um endpoint para inferência.

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 pacotes: azure-ai-ml, pandas, scikit-learn, joblib.
Conjunto de dados de clientes (CSV) com colunas numéricas e categóricas simples.

Passo 1: Criar o workspace e configurar o ambiente

Precisamos de um Azure Machine Learning workspace e de um ambiente Python com dependências. Se já tiver o workspace, avance. Caso contrário, crie-o com a CLI e configure as credenciais 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

Passo 2: Preparar e carregar os dados

Carregue o CSV de clientes, trate valores em falta e converta variáveis categóricas. Para clustering, normalizar atributos numéricos é essencial para evitar viés.

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)

Passo 3: Treinar o modelo KMeans localmente

Treinar localmente ajuda a iterar rápido. KMeans é simples e interpretável para segmentação. Experimente diferentes valores de k e use o método do cotovelo ('elbow') para escolher.

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

Passo 4: Criar um script de scoring e empacotar para deployment

Para publicar um endpoint no Azure ML, crie um script que carrega o modelo e recebe novos registos em JSON/CSV para prever o cluster. Mantenha o código mínimo e robusto para erros comuns (colunas em falta).

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

Passo 5: Publicar o modelo como endpoint no Azure Machine Learning

Use o SDK azure-ai-ml para registar o modelo e criar um endpoint para inferência em tempo real. Aqui mostramos os passos essenciais; ajuste recursos e políticas conforme necessário.

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 o resultado

Teste o endpoint com um payload de exemplo e confirme que recebe clusters válidos. Verifique também métricas de utilização e logs no Azure Machine Learning Studio para resolver erros comuns (erros de serialização, colunas em falta).

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

Conclusão

Fez clustering de clientes em Azure AI & Machine Learning: preparou dados, treinou KMeans, escreveu um scoring script e publicou um endpoint. Próximos passos: experimentar outros algoritmos (DBSCAN, GaussianMixture), avaliar estabilidade dos clusters e integrar segmentação com campanhas. Dica: teste sempre com casos reais e verifique se as variáveis usadas são relevantes para marketing.