Como detetar fraudes em transações com Azure ML: passo a passo

Este tutorial mostra como detetar fraudes em transações com Azure Machine Learning, útil para reduzir perdas e automatizar anomalias em pagamentos. Vai aprender por que usar features, treino e deployment para obter previsões em tempo real.

Pré-requisitos

• Conta Azure com subscrição ativa e permissões para criar recursos.
• Azure Machine Learning workspace criado.
• Python 3.8+ instalado localmente e pip; pacotes: azure-ai-ml, azure-ml, scikit-learn, pandas.
• Dataset de transações em CSV (colunas: transaction_id, amount, timestamp, merchant, customer_id, label).
• Familiaridade básica com ML (features, treino, avaliação).

Passo 1: Preparar o ambiente e carregar o dataset

Crie um ambiente Python e instale as bibliotecas. Em seguida ligue-se ao workspace e carregue o CSV para um DataFrame. É importante validar tipos e valores em campos como amount e timestamp.

pip install azure-ai-ml azure-identity scikit-learn pandas joblib

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential
import pandas as pd

ws = MLClient(DefaultAzureCredential(), subscription_id="", resource_group_name="", workspace_name="")
df = pd.read_csv('transactions.csv')
df['timestamp'] = pd.to_datetime(df['timestamp'])
print(df.head())

Passo 2: Pré-processamento e engenharia de features

Explique por que: features bem construídas melhoram a deteção de fraude (por exemplo, frequência do cliente, valor médio, hora do dia). Crie colunas como hour, txn_per_customer, avg_amount_customer. Trate valores em falta e normalize amount.

# Exemplo simples de features
import numpy as np

df['hour'] = df['timestamp'].dt.hour
cust_stats = df.groupby('customer_id')['amount'].agg(['count','mean']).rename(columns={'count':'txn_count','mean':'avg_amount'})
df = df.merge(cust_stats, on='customer_id')

df['amount_norm'] = (df['amount'] - df['avg_amount']) / (df['amount'].std() + 1e-9)

features = ['amount_norm','hour','txn_count']
X = df[features].fillna(0)
y = df['label']  # 1 = fraud, 0 = legit

Passo 3: Treinar um modelo de classificação

Por que: modelos tree-based funcionam bem com features tabulares. Aqui usamos RandomForest para um exemplo rápido. Guarde o modelo com joblib para deployment.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
import joblib

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=42)
model = RandomForestClassifier(n_estimators=100, class_weight='balanced', random_state=42)
model.fit(X_train, y_train)

preds = model.predict(X_test)
print(classification_report(y_test, preds))
joblib.dump(model, 'fraud_rf.joblib')

Passo 4: Registar e empacotar o modelo no Azure Machine Learning

Registe o ficheiro do modelo no workspace para gestão de versões. Crie um ambiente de execução (conda) e um scoring script simples que carrega o modelo e prevê a label.

from azure.ai.ml.entities import Model

model_aml = Model(path='fraud_rf.joblib', name='fraud-rf-model', description='RandomForest para deteção de fraude')
registered = ws.models.create_or_update(model_aml)
print('Model registered:', registered.name)

Passo 5: Criar um container image / endpoint de inferência

Por que: um endpoint permite previsões em tempo real. Defina o scoring script que processa JSON com as mesmas features e devolve probabilidade. Depois crie um deployment como Managed Online Endpoint ou compute que suporte o container.

# scoring.py (simplificado)
import json
import joblib
import numpy as np

def init():
    global model
    model = joblib.load('fraud_rf.joblib')

def run(raw_data):
    data = json.loads(raw_data)
    X = np.array([data['amount_norm'], data['hour'], data['txn_count']]).reshape(1,-1)
    pred = model.predict_proba(X)[0,1]
    return {'fraud_probability': float(pred)}

Passo 6: Testar localmente e implementar no Azure

Teste o scoring script localmente com um exemplo JSON. Depois crie o endpoint Managed Online Endpoint no Azure ML e faça o deploy do container com a imagem que inclui scoring.py e o modelo registado.

# Teste local (exemplo)
import requests, json
payload = {'amount_norm':0.5,'hour':2,'txn_count':10}
print(run(json.dumps(payload)))

# No Azure: criar endpoint e deployment via Azure ML CLI/SDK (resumo):
# az ml online-endpoint create -n fraud-endpoint -f endpoint.yml
# az ml online-deployment create -n deployment1 --endpoint fraud-endpoint -f deployment.yml

Verificar o resultado

Confirme que o endpoint responde e que a precisão/recall são aceitáveis. Envie exemplos reais e verifique probabilidades para fraudes conhecidas. Monitorize métricas (TP, FP) e latência no painel do Azure Machine Learning.

Conclusão

Acabou de criar um fluxo completo para deteção de fraude em transações com Azure Machine Learning: preparação, treino, registo e deployment de um endpoint de inferência. Próximos passos: ajustar features, experimentar XGBoost ou LightGBM, e integrar alertas. Dica: valide com dados recentes e implemente thresholds dinâmicos para reduzir falsos positivos.