# Como criar um modelo de Machine Learning com Databricks

> Aprenda em 5 passos como criar e implantar um modelo de Machine Learning no Databricks usando Spark e MLflow.

URL: https://bixtecnologia.com.br/5-passos-para-criar-um-modelo-de-machine-learning-do-zero-no-databricks-tutorial-completo/
Idioma: pt-BR
Publicado em: 2025-11-12T14:48:24.000Z

## 5 passos para criar um modelo de Machine Learning do zero no Databricks: Tutorial Completo

12 de novembro de 2025

8 min de leitura

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](https://www.youtube.com/watch?v=VM7eubO5moo).

## 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](https://www.databricks.com/) é 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.

Exemplo das colunas que trabalharemos no tutorial.

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ítima
- `1` → 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](https://bixtecnologia.com.br/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](https://community.cloud.databricks.com/) e testar um modelo básico com o [ML Flow](https://mlflow.org/).

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:

[![Miniatura do vídeo do canal BIX Tecnologia no YouTube: Tutorial: Do zero ao Modelo com Databricks | Semana de Dados 2025](https://images.bix-tech.com/video_card_VM_7eub_O5moo_75001e1084.jpg)](https://www.youtube.com/watch?v=VM7eubO5moo)

Tutorial: Do zero ao Modelo com Databricks \| Semana de Dados 2025, no canal BIX Tecnologia no YouTube.

## Artigos relacionados

Machine Learning

Engenharia de Dados

### [Model registry: versionar e rastrear modelos em produção](https://bixtecnologia.com.br/model-registry-versionamento-modelos/)

O que o model registry guarda e como promover modelos até a produção.

15 de setembro de 2026

12 min de leitura

![Ilustração de um modelo de machine learning distribuindo predições por três caminhos: batch agendado, endpoint online e stream de eventos](https://bixtecnologia.com.br/img/cover_pt_7d01d30c81-960.webp)

Machine Learning

Engenharia de Dados

### [Model serving: quando usar inferência batch ou online](https://bixtecnologia.com.br/model-serving-batch-online/)

Escolha o modo de model serving: batch, endpoint online ou stream.

8 de setembro de 2026

20 min de leitura

Machine Learning

Engenharia de Dados

### [Drift de modelo: como detectar degradação em produção](https://bixtecnologia.com.br/drift-de-modelo-monitoramento/)

Como detectar drift de modelo em produção com PSI, KS e qui-quadrado.

1 de setembro de 2026

13 min de leitura

![Ilustração de uma feature store: um repositório central de features ramificando para um armazenamento offline e um online até um modelo de machine learning](https://bixtecnologia.com.br/img/cover_pt_849ce5a0df-960.webp)

Machine Learning

Engenharia de Dados

### [Feature store: o que é, quando usar e como construir](https://bixtecnologia.com.br/feature-store-o-que-e-quando-usar/)

O que é uma feature store, quando usar e como construir a sua.

11 de agosto de 2026

9 min de leitura

Machine Learning

Engenharia de Dados

### [MLOps em 2026: arquitetura de referência para deploy e monitoramento](https://bixtecnologia.com.br/arquitetura-de-mlops-2026/)

Guia da arquitetura de MLOps em 2026: deploy e monitoramento de modelos.

7 de agosto de 2026

17 min de leitura

![Ilustração do pipeline de RAG em produção, de documentos e chunks ao modelo de IA que gera uma resposta validada](https://bixtecnologia.com.br/img/cover_pt_ec8c2727f7-960.webp)

Inteligência Artificial

Machine Learning

### [RAG em produção em 2026: padrões avançados, avaliação e quando usar fine-tuning](https://bixtecnologia.com.br/rag-em-producao-2026/)

RAG em produção: padrões, avaliação e quando usar fine-tuning.

7 de julho de 2026

9 min de leitura

---

BIX Tecnologia · Contato: https://bixtecnologia.com.br/contato/
Índice do site para agentes: https://bixtecnologia.com.br/llms.txt