Como Construir Seu Primeiro Modelo de Aprendizado de Máquina em Python (2026)

A melhor maneira de entender o aprendizado de máquina é construir um modelo você mesmo. É muito menos intimidador do que parece — com Python e a biblioteca certa, seu primeiro modelo funcional tem cerca de 20 linhas de código. Este tutorial percorre todos os passos, explicando não apenas o que digitar, mas também por quê.

O que você construirá

Você construirá um classificador — um modelo que classifica itens em categorias. Usaremos o clássico conjunto de dados para iniciantes, o conjunto de dados Iris: medições de flores íris (comprimento e largura das pétalas e sépalas), onde a tarefa é prever a espécie da flor. É pequeno, limpo e integrado ao scikit-learn, tornando-o ideal para seu primeiro modelo.

Os mesmos cinco passos que você aprenderá aqui se aplicam a quase todos os projetos de aprendizado de máquina, independentemente do tamanho.

Passo 1: Configure suas ferramentas

Você precisa do Python e de duas bibliotecas. scikit-learn é a biblioteca principal — fornece conjuntos de dados, algoritmos e ferramentas de avaliação em uma interface consistente e acessível para iniciantes.

Instale-as a partir do seu terminal:

pip install scikit-learn pandas

Você pode escrever o código em um simples arquivo .py mas um notebook Jupyter (ou um notebook em nuvem gratuito, como o Google Colab) é ideal para aprendizado — você executa o código em pequenas partes e vê cada resultado imediatamente.

Passo 2: Carregue os dados

Todo projeto de aprendizado de máquina começa com dados. Aqui carregamos o conjunto de dados Iris integrado:

from sklearn.datasets import load_iris

iris = load_iris()
X = iris.data # the measurements (the inputs / features)
y = iris.target # the species (the labels / answers)

print("Shape of X:", X.shape) # (150, 4) — 150 flowers, 4 measurements each
print("Classes:", iris.target_names)

Duas variáveis são importantes aqui, e a convenção de nomenclatura é universal:

• X armazena as características — as entradas das quais o modelo aprende (as quatro medições).
• y armazena as rótulos — as respostas corretas (a espécie).

Como temos as respostas, trata-se de aprendizado supervisionado.

Etapa 3: Dividir os dados

Este é o passo mais importante para obter um resultado honesto. Você deve dividir seus dados em duas partes:

• A conjunto de treinamento o modelo aprende a partir dele.
• A conjunto de teste o modelo nunca vê durante o treinamento — usado exclusivamente para avaliá-lo.

Se você fizesse o teste nos mesmos dados usados para treinar, estaria apenas medindo memorização, não aprendizado real. (É assim que você identifica sobreajuste.)

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
 X, y, test_size=0.2, random_state=42
)

test_size=0.2 reserva 20% dos dados para teste e usa os outros 80% para treinamento. random_state=42 simplesmente torna a divisão aleatória reproduzível, garantindo que você obtenha o mesmo resultado em cada execução.

Etapa 4: Escolher e treinar um modelo

Agora começa o aprendizado de máquina propriamente dito. Usaremos uma Floresta Aleatória (Random Forest) — um algoritmo preciso, confiável e adequado para iniciantes (consulte nosso guia de algoritmos).

No scikit-learn, treinar um modelo exige apenas duas linhas:

from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)

Essa chamada .fit() realiza é o treinamento. O modelo analisa as características do conjunto de treinamento e seus rótulos, aprendendo os padrões que associam as medições à espécie. O scikit-learn cuida de toda a matemática por trás dessa única linha.

Etapa 5: Avaliar o modelo

Agora verifique o quão bem ele aprendeu — usando o conjunto de teste, que nunca foi visto pelo modelo:

from sklearn.metrics import accuracy_score

predictions = model.predict(X_test)
accuracy = accuracy_score(y_test, predictions)

print(f"Acurácia: {accuracy:.2%}")

.predict() solicita ao modelo que classifique as flores do conjunto de teste; accuracy_score compara suas previsões com as respostas verdadeiras. No conjunto de dados Iris, normalmente obtém-se uma acurácia entre 95% e 100% — ou seja, o modelo identifica corretamente quase todas as flores que nunca havia visto antes.

Etapa 6: Fazer uma previsão com novos dados

O benefício prático real: usar o modelo com entradas inteiramente novas. Basta fornecer um conjunto de medições para que ele preveja a espécie:

new_flower = [[5.1, 3.5, 1.4, 0.2]] # sepal & petal measurements
prediction = model.predict(new_flower)

print("Predicted species:", iris.target_names[prediction[0]])

Trata-se de um modelo completo de aprendizado de máquina: treinado, testado e capaz de fazer previsões com dados que nunca encontrou anteriormente.

O fluxo de trabalho completo

Essas cinco etapas não são apenas um exercício — constituem a estrutura fundamental de praticamente todo projeto de ML supervisionado:

Projetos maiores incluem limpeza de dados, preparação de características e ajuste do modelo — mas esse ciclo principal permanece inalterado.

Para onde ir a seguir

Para continuar desenvolvendo:

• Experimente outros algoritmos — substitua RandomForestClassifier para LogisticRegression ou SVC e comparar. A interface consistente do scikit-learn torna isso trivial.
• Experimente outros conjuntos de dados — pratique com conjuntos de dados gratuitos aqueles que lhe interessam.
• Aprenda a preparação de dados — dados reais são desorganizados; limpar e prepará-los representa a maior parte do trabalho.
• Explore a avaliação — acurácia é apenas uma métrica; aprenda precisão, revocação (recall) e validação cruzada.

Erros comuns que silenciosamente comprometem seu primeiro modelo

Seu modelo foi treinado e exibiu uma pontuação de acurácia — mas um número aparentemente bom não equivale necessariamente a um modelo funcional. Essas são as armadilhas em que os iniciantes caem com mais frequência, e todas elas são fáceis de evitar assim que você as conhecer.

• Avaliar o modelo com dados já vistos durante o treinamento. Se você medir a acurácia nos dados de treinamento, estará avaliando o modelo com base nas respostas que ele simplesmente memorizou. Uma pontuação de 100% nesse contexto não significa nada. Avalie sempre no conjunto de teste reservado, criado na etapa de divisão dos dados — esse é o único valor que estima o desempenho no mundo real.
• Vazamento de dados (data leakage): permitir que dados de teste influenciem o treinamento. Trata-se do erro mais prejudicial e menos óbvio. Se você padronizar, normalizar ou preencher valores ausentes antes antes da divisão, estatísticas provenientes do conjunto de teste (como a média de uma coluna) acabam vazando para o treinamento e inflacionando artificialmente sua pontuação. A solução é seguir uma ordem estrita: divida os dados primeiro e, só então, ajuste (fit) qualquer transformador exclusivamente no conjunto de treinamento e simplesmente aplique (apply) essa transformação ao conjunto de teste. A documentação do scikit-learn destaca esse problema como uma das armadilhas mais comuns em machine learning.
• Esquecer de escalar os dados quando o algoritmo exigir essa etapa. Modelos baseados em distância ou gradiente (k-vizinhos mais próximos, SVMs, regressão logística) apresentam mau desempenho quando uma característica varia entre 0 e 1, enquanto outra varia entre 0 e 100.000. Já modelos baseados em árvores, como florestas aleatórias, não são afetados por essa disparidade. Saiba a qual categoria pertence seu algoritmo.
• Confiar cegamente na acurácia em dados desbalanceados. Se 95% dos seus exemplos pertencerem a uma única classe, um modelo que sempre preveja essa classe obterá 95% de acurácia, mesmo sendo inútil. Quando as classes estiverem desproporcionais, examine a precisão, a revocação (recall) e a pontuação F1 fornecidas pela função classification_report em vez de considerar apenas a acurácia.

A defesa mais eficaz contra vazamento de dados é um Pipelinepipeline.

• from sklearn.pipeline import make_pipeline
• model = make_pipeline(StandardScaler(), LogisticRegression())
• Em seguida, chame model.fit(X_train, y_train) exatamente como antes.

Um último hábito valioso para desenvolver cedo: uma única divisão treino/teste é uma estimativa ruidosa. Executar novamente com uma divisão aleatória diferente pode alterar sua pontuação em vários pontos. Assim que se sentir confortável, substitua essa divisão única por cross_val_score, que treina e testa em várias partições (folds) e relata a média — uma avaliação muito mais honesta sobre se seu modelo realmente aprendeu algo.

Perguntas frequentes

Como construo um modelo de machine learning em Python?

Use a biblioteca scikit-learn. O fluxo de trabalho é: carregue seus dados em características (X) e rótulos (y), divida-os em conjuntos de treinamento e teste, crie um modelo e chame .fit() para treiná-lo, avalie-o no conjunto de teste e use .predict() para novos dados. Um primeiro modelo tem cerca de 20 linhas de código.

Qual biblioteca os iniciantes devem usar para machine learning?

scikit-learn. Ela oferece uma ampla gama de algoritmos, conjuntos de dados embutidos e ferramentas de avaliação por meio de uma única interface simples e consistente, além de lidar automaticamente com a matemática subjacente. É o ponto de partida padrão antes de avançar para frameworks de deep learning.

Preciso ser bom em matemática para construir um modelo de ML?

Não. Para construir modelos com o scikit-learn, basta ter conhecimentos básicos de Python e compreender o fluxo de trabalho. A biblioteca cuida da matemática. Um conhecimento mais profundo da matemática torna-se útil posteriormente, caso deseje ajustar modelos com expertise ou realizar pesquisas.

Por que preciso dividir os dados em conjuntos de treinamento e teste?

Para medir o desempenho real. Se você testar um modelo nos mesmos dados em que ele foi treinado, estará apenas medindo sua capacidade de memorização. Um conjunto de teste separado — que o modelo nunca viu — revela se ele realmente aprendeu o padrão e consegue generalizar para novos dados.

O que faz o método model.fit()?

.fit() é a etapa de treinamento. Ele fornece ao algoritmo as características e rótulos de treinamento, permitindo que este ajuste seus parâmetros internos para aprender os padrões que conectam as entradas às respostas corretas. Após .fit(), o modelo está treinado e pronto para fazer previsões.

Meu modelo obteve alta acurácia — isso significa que ele é bom?

Não necessariamente. Alta acurácia só é significativa se for medida no conjunto de teste reservado, não nos dados de treinamento, e se suas classes estiverem razoavelmente balanceadas. Em um conjunto de dados onde uma classe predomina, uma pontuação alta pode resultar simplesmente do modelo adivinhar sempre a classe majoritária. Verifique a precisão, a revocação (recall) e a pontuação F1 com classification_report, e confirme que o valor foi calculado com dados que o modelo nunca viu durante o treinamento.

Como faço para salvar meu modelo treinado e usá-lo posteriormente?

Use a biblioteca joblib do Python, que acompanha o scikit-learn. Chame joblib.dump(modelo, "modelo.joblib") para gravar o modelo treinado no disco e joblib.load("modelo.joblib") para carregá-lo em outro script — sem necessidade de novo treinamento. Salve todo o Pipeline, não apenas o estimador final, para que suas etapas de escalonamento e pré-processamento acompanhem o modelo, garantindo que novas entradas sejam tratadas de forma idêntica.

Como faço para migrar de um conjunto de dados embutido para meus próprios dados?

Carregue seus dados com o pandas — pandas.read_csv("seuarquivo.csv") — e, em seguida, separe suas colunas de entrada (características, geralmente chamadas de XX yy

Conclusão

Construir seu primeiro modelo de machine learning é, de fato, um projeto curto e totalmente viável: instale o scikit-learn, depois carregue, divida, treine, avalie e faça previsões. Esses cinco passos constituem a base da quase totalidade dos projetos de ML supervisionado que você desenvolverá ao longo da sua trajetória.

Não se limite a ler este texto — abra um notebook e execute o código. Altere o algoritmo, experimente um conjunto de dados diferente, provoque erros e resolva-os. Os conceitos de machine learning se consolidam muito mais rapidamente assim que você treinar um modelo com as próprias mãos. Quando estiver pronto para mais, obtenha um conjunto de dados gratuito e construa algo próprio.