Criar, treinar e colocar em produção um modelo de Machine Learning de ponta a ponta em um único ambiente é mais simples do que parece, principalmente quando usamos o Databricks.
Quem trabalha com ciência de dados sabe que as etapas de exploração, modelagem e deploy normalmente acontecem em ferramentas diferentes, o que torna o processo mais lento e suscetível a falhas.
O Databricks unifica tudo isso: um espaço colaborativo, escalável e integrado, onde é possível fazer desde a engenharia de dados até o deploy do modelo final.
Neste artigo, você vai aprender como desenvolver um modelo completo de Machine Learning no Databricks, seguindo 5 passos práticos, da análise exploratória à produção. E se preferir acompanhar o tutorial em vídeo, é só clicar aqui para assistir no YouTube.
O que é Machine Learning
De forma simples, Machine Learning (ou aprendizado de máquina) é o campo da inteligência artificial que ensina os computadores a aprender com dados.
Ao trabalhar com milhões de registros, identificar padrões manualmente é impossível. O aprendizado de máquina faz isso por nós, encontrando relações e comportamentos que não são visíveis a olho nu.
Essa tecnologia está presente nas recomendações de filmes, nas sugestões de compra de e-commerces e até nas análises de transações financeiras. Quando o banco bloqueia uma compra suspeita, há um modelo de Machine Learning tomando essa decisão em segundos.
O que é o Databricks?
O Databricks é uma plataforma em nuvem projetada para unificar todo o trabalho com dados.
Com ele, posso fazer desde a engenharia de dados até a modelagem de Machine Learning no mesmo ambiente. O Databricks é compatível com as principais nuvens (AWS, Azure e GCP) e integra nativamente ferramentas poderosas, como o Apache Spark e o MLflow.
Além disso, o ambiente é colaborativo e funciona com notebooks, o que facilita muito o trabalho em equipe. Tudo acontece de forma fluida, sem precisar alternar entre linguagens ou janelas diferentes.
Por que usar o Databricks para Machine Learning?
O principal motivo para como criar um modelo de machine learning é a integração.
Aqui, você consegue realizar todo o ciclo de um modelo em um só lugar:
- leitura e exploração dos dados,
- tratamento e engenharia de atributos,
- treinamento e comparação de modelos,
- e o deploy em produção.
O Databricks permite usar Python, SQL e Spark na mesma interface. Isso significa que podemos começar com uma análise exploratória em pandas e, na célula seguinte, executar o mesmo processo com Spark para lidar com grandes volumes de dados.
Outro destaque é o MLflow, que registra automaticamente todos os experimentos, parâmetros e métricas de performance. Isso facilita a escolha do melhor modelo e economiza tempo de documentação.
Agora que já vimos os conceitos de ML, Databricks e os motivos para integrá-los, é hora de partir para os 5 passos que colocam o modelo de Databricks em ação!
PASSO 1 – Preparando o ambiente e lendo o dataset
Vamos começar criando o cluster e importando o dataset que será usado para o projeto.
Neste caso, utilizamos um dataset de transações com cartão de crédito, com mais de 1 milhão de registros. O objetivo é prever se uma transação é fraudulenta (1) ou legítima (0).
Como é comum nesse tipo de problema, o conjunto é altamente desbalanceado, apenas cerca de 0,6% das transações são fraudes.
O primeiro passo é carregar os dados no Databricks:
df = spark.read.format("csv") \
.option("header", "true") \
.option("inferSchema", "true") \
.load("/FileStore/tables/creditcard.csv")
df.display()O método display() do Databricks facilita a visualização inicial dos dados.
A partir daqui, você pode inspecionar as colunas, tipos de dados e estatísticas básicas diretamente no notebook.
Passo 2 – Análise exploratória dos dados
Com o dataset carregado, é hora de fazer a análise exploratória.
No Databricks, é possível alternar entre pandas e Spark DataFrames facilmente. Para verificações simples, pandas é rápido e direto; para grandes volumes, Spark é ideal.
import pandas as pd
# Conversão para pandas para visualização rápida
pdf = df.limit(10000).toPandas()
# Verificação de nulos e duplicatas
print(pdf.isnull().sum())
print(pdf.duplicated().sum())Durante essa etapa, verificamos:
- existência de valores nulos;
- duplicidades;
- distribuições de variáveis;
- comportamento da variável-alvo (fraude vs. não fraude).
Também é possível usar visualizações interativas do Databricks para entender padrões iniciais, como a relação entre valor da transação e probabilidade de fraude.
Passo 3 – Engenharia de atributos (Feature Engineering)
Depois de explorar o dataset, partimos para a engenharia de atributos, a criação de novas colunas que ajudam o modelo a compreender melhor o comportamento dos dados.
Um exemplo é extrair a bandeira do cartão (Visa, MasterCard, etc.) a partir dos primeiros dígitos:
from pyspark.sql.functions import col, substring, when
df = df.withColumn("bandeira",
when(substring(col("card_number"), 1, 1) == "4", "Visa")
.when(substring(col("card_number"), 1, 1) == "5", "MasterCard")
.otherwise("Outros"))Outras transformações incluem:
- converter variáveis categóricas em dummies ou one-hot encoding;
- normalizar colunas numéricas, quando necessário;
- criar variáveis derivadas, como hora do dia da transação ou média de gasto por usuário.
Atenção: em projetos de fraude, é comum lidar com outliers, e eles são justamente os casos que o modelo precisa aprender a reconhecer.
Por isso, não remova nem normalize valores extremos sem avaliar o impacto. O algoritmo precisa aprender a distinguir esses padrões incomuns.
Passo 4 – Modelagem e rastreamento com MLflow
Com os dados preparados, vamos para a modelagem preditiva.
O Databricks oferece integração direta com MLflow, que registra automaticamente parâmetros, métricas e artefatos de cada experimento.
Aqui, treinamos três modelos de classificação:
import mlflow
import mlflow.sklearn
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score, f1_score, roc_auc_score
# Separando treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
models = {
"RandomForest": RandomForestClassifier(),
"XGBoost": XGBClassifier(),
"XGBoost Balanced": XGBClassifier(scale_pos_weight=100)
}
for name, model in models.items():
with mlflow.start_run(run_name=name):
model.fit(X_train, y_train)
preds = model.predict(X_test)
acc = accuracy_score(y_test, preds)
f1 = f1_score(y_test, preds)
auc = roc_auc_score(y_test, preds)
mlflow.log_metric("accuracy", acc)
mlflow.log_metric("f1_score", f1)
mlflow.log_metric("auc", auc)
mlflow.sklearn.log_model(model, name)Com isso, o MLflow armazena automaticamente os resultados de cada execução.
No painel do Databricks, você pode comparar experimentos lado a lado e identificar o melhor modelo, neste caso, o XGBoost balanceado teve desempenho superior, com acurácia acima de 70% e melhor F1-score.
Passo 5 – Salvando e colocando o modelo em produçãomodelo
Depois de escolher o modelo vencedor, é hora de registrá-lo e disponibilizá-lo em produção.
O Model Registry do Databricks permite versionar modelos, controlar estágios (Staging, Production) e até gerar endpoints para consumo via API.
import mlflow.pyfunc
# Registrar o modelo no Model Registry
result = mlflow.register_model(
"runs:/<run_id>/model",
"ModeloDeteccaoFraude"
)Com o modelo publicado, é possível integrá-lo em sistemas de decisão automatizados.
Por exemplo, em um ambiente bancário, cada nova transação pode ser enviada para o endpoint do modelo, que retorna:
0→ transação legítima1→ possível fraude
Esse retorno pode ser usado para bloquear transações suspeitas ou acionar alertas automáticos.
FAQ
Por que usar o Databricks e não outro ambiente?
Porque o Databricks unifica exploração, processamento, treinamento e deploy em um só lugar, sem precisar alternar ferramentas ou linguagens.
Preciso saber Spark para acompanhar o tutorial?
Não. Você pode começar com pandas e escalar para Spark conforme o volume de dados.
Como lidar com dados desbalanceados?
Usamos modelos balanceados, como o XGBoost com scale_pos_weight. Também é possível aplicar oversampling ou undersampling dependendo do cenário.
Posso aplicar esse fluxo a outros tipos de problema?
Sim! Os mesmos passos se aplicam a qualquer projeto de classificação ou regressão, basta ajustar o dataset e as métricas.
Próximos passos para criar um modelo
O Databricks permite desenvolver, testar e colocar modelos de Machine Learning em produção de forma simples e escalável.
Se quiser experimentar, recomendo criar uma conta no Databricks Community Edition e testar um modelo básico com o ML Flow.
A melhor forma de aprender é explorando a ferramenta e colocando a mão na massa.
Entre em contato
Coloque esse fluxo em prática e aplique esse processo na sua empresa falando com a nossa equipe!
E se preferir acompanhar o tutorial em vídeo, é só clicar abaixo:
