Para começar com machine learning com Python, escolha uma tarefa pequena, separe os dados de treino e teste e compare um modelo simples com uma referência básica. Você não precisa alugar uma GPU para o primeiro exercício. Neste guia, vamos montar um classificador completo em CPU, interpretar seus erros e decidir quando faz sentido mudar a infraestrutura.
O objetivo é sair com um experimento que você consegue repetir e explicar. Acertar uma previsão isolada é menos útil do que saber quais dados o modelo viu, como foi avaliado e onde ele falha.
O que aprender primeiro em machine learning com Python
Um projeto de aprendizado supervisionado tem entradas, chamadas de atributos, e uma resposta conhecida, chamada de alvo. No exemplo deste artigo, os atributos são medidas de flores e o alvo é a espécie. O modelo aprende uma relação usando o conjunto de treino e depois tenta classificar exemplos que ficaram separados.
Antes de escolher uma biblioteca, escreva a pergunta que deseja responder:
| Tarefa | Tipo de resposta | Primeiro experimento possível |
|---|---|---|
| Classificar uma observação | Uma categoria | Regressão logística ou árvore de decisão |
| Estimar uma quantidade | Um número | Regressão linear e análise dos erros |
| Encontrar grupos sem rótulos | Agrupamentos | Um método de clustering e inspeção dos grupos |
| Trabalhar com imagens ou linguagem em grande escala | Representações e previsões mais complexas | Uma biblioteca apropriada de deep learning, depois de definir a avaliação |
Não escolha uma rede neural apenas porque ela parece mais avançada. Se uma solução simples resolve a tarefa dentro do custo e do prazo necessários, ela é uma referência importante para qualquer alternativa posterior.
Prepare um ambiente isolado
Você precisa de uma instalação de Python compatível com o scikit-learn e de acesso ao terminal. Crie uma pasta de trabalho e um ambiente virtual para evitar conflitos com outros projetos:
python -m venv .venv
No macOS ou Linux, ative com source .venv/bin/activate. No PowerShell do Windows, use .venv\Scripts\Activate.ps1, conforme as políticas locais do terminal. Depois instale a biblioteca e registre as versões:
python -m pip install scikit-learn
python -m pip freeze > requirements.txt
Use python3 no lugar de python se esse for o nome do executável no seu computador. O arquivo de dependências ajuda a recriar o ambiente; guarde também a versão do Python, o código e a configuração do experimento.
Um primeiro modelo completo: classificação de flores
O conjunto Iris do scikit-learn contém 150 observações, quatro atributos numéricos e três classes. É pequeno e adequado para aprender o fluxo de trabalho, mas não demonstra que um sistema está pronto para dados reais.
Salve o código abaixo como exemplo_iris.py e execute python exemplo_iris.py. Ele usa 120 observações para treino e 30 para teste. A divisão estratificada mantém a representação das classes; a semente fixa permite repetir a mesma divisão.
import platform
from time import perf_counter
import sklearn
from sklearn.datasets import load_iris
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, f1_score, confusion_matrix
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.20, random_state=42, stratify=y
)
models = {
"baseline": DummyClassifier(strategy="most_frequent"),
"logistica": make_pipeline(
StandardScaler(), LogisticRegression(max_iter=1000)
),
}
for name, model in models.items():
start = perf_counter()
model.fit(X_train, y_train)
train_seconds = perf_counter() - start
pred = model.predict(X_test)
print(name, "acuracia=", round(accuracy_score(y_test, pred), 3),
"f1_macro=", round(f1_score(
y_test, pred, average="macro", zero_division=0
), 3))
print("matriz de confusao:", confusion_matrix(y_test, pred).tolist())
print("tempo de treino (s):", round(train_seconds, 6))
print("Python:", platform.python_version(),
"scikit-learn:", sklearn.__version__)
O DummyClassifier fornece uma comparação que não aprende uma relação entre os atributos e a classe. Com a estratégia usada aqui, ele prevê a classe mais frequente do treino. Se um modelo mais elaborado não melhora uma referência assim, investigue dados, objetivo e avaliação antes de gastar mais recursos. Veja as estratégias na documentação do DummyClassifier.
A regressão logística recebe os dados por uma Pipeline: primeiro a padronização, depois o classificador. As transformações são ajustadas no treino e reaplicadas ao teste. Isso evita calcular a escala usando informações que deveriam estar reservadas para avaliação, uma forma comum de vazamento de dados. A documentação de boas práticas do scikit-learn explica esse cuidado.
Como interpretar a saída sem se enganar
Na execução deste exemplo em CPU, com Python 3.14.4 e scikit-learn 1.9.1, obtivemos os resultados abaixo. São resultados do exercício e desta divisão dos dados, não uma promessa para outro conjunto.
| Modelo | Acurácia no teste | F1 macro |
|---|---|---|
| Referência de classe mais frequente | 0,333 | 0,167 |
| Padronização + regressão logística | 0,933 | 0,933 |
A matriz do segundo modelo foi [[10, 0, 0], [0, 9, 1], [0, 1, 9]]: duas das 30 flores do teste foram confundidas entre as duas últimas classes. Isso é mais informativo que dizer apenas que o modelo acertou cerca de 93%.
A acurácia indica a proporção de previsões corretas no conjunto avaliado. O F1 macro calcula o F1 de cada classe e faz uma média sem dar peso maior à classe mais frequente. A matriz de confusão mostra quais classes foram confundidas. Use as três leituras para entender o comportamento, em vez de procurar somente o maior número.
O tempo impresso é apenas o tempo de treino daquela execução no seu computador. Em um conjunto tão pequeno, ele varia com a máquina e com o ruído de medição. Não use esse número para prometer economia em nuvem ou comparar CPU e GPU.
O resultado do Iris também não deve virar uma expectativa de precisão para seu produto. Em dados próprios, a distribuição, a qualidade dos rótulos e o custo dos erros podem ser completamente diferentes. Uma falha rara pode ser mais importante que dezenas de acertos fáceis.
Antes de mudar o algoritmo, responda:
- O modelo superou a referência básica usando exatamente o mesmo teste?
- Qual classe concentra os erros e qual é o impacto deles na tarefa?
- Existe informação nas entradas que só estaria disponível depois da previsão?
- O teste representa exemplos novos ou contém duplicatas e observações relacionadas ao treino?
- O desempenho se mantém em outras divisões válidas dos dados?
Do exercício para um conjunto de dados real
A divisão aleatória é conveniente para o Iris. Ela pode ser inadequada se você prevê eventos futuros, tem várias linhas por cliente ou encontra cópias da mesma observação. Nesses casos, considere uma separação temporal ou por grupos, de acordo com a forma como o modelo será usado. O parâmetro random_state não corrige uma divisão conceitualmente errada. A referência de train_test_split descreve os controles disponíveis para essa divisão simples.
Reserve a validação para escolher configurações e mantenha um teste final separado. Se você consulta o teste repetidamente para decidir o próximo ajuste, ele passa a influenciar suas escolhas. Para um projeto pequeno, uma planilha de experimentos já ajuda:
| Registro | O que anotar |
|---|---|
| Dados | Origem, data, tamanho, colunas e regra de exclusão |
| Divisão | Temporal, por grupos ou aleatória; semente quando aplicável |
| Modelo | Algoritmo, parâmetros e versão das dependências |
| Avaliação | Métrica principal, erros por classe e comparação com a referência |
| Operação | Tempo, memória, tamanho do artefato e custo medido |
| Decisão | O que melhorou e qual problema continua aberto |
Quando substituir o Iris por uma tabela própria, valide tipos, campos ausentes e categorias antes de treinar. Mantenha as transformações junto do modelo para que a previsão use a mesma preparação dos dados. Uma coluna que mudou de unidade pode causar problemas mesmo que o código continue executando.
Quando uma GPU ajuda — e quando não ajuda
O exemplo deste guia trabalha em CPU. Adicionar uma placa à máquina não faz automaticamente todo código do scikit-learn usá-la. O projeto documenta suporte a GPU para um conjunto limitado de estimadores e configurações, inclusive por meio de entradas e opções específicas. Verifique o caminho exato do algoritmo escolhido.
Uma GPU merece um experimento quando há uma implementação compatível e uma carga que pode aproveitá-la, como determinados treinamentos de redes neurais ou processamento em lotes. Ainda assim, o ganho precisa compensar transferência de dados, preparação do ambiente e custo da infraestrutura.
| Situação observada | Próxima ação recomendada |
|---|---|
| Poucos dados e treino rápido em CPU | Priorizar qualidade dos dados e avaliação |
| Leitura ou preparação consome a maior parte do tempo | Medir armazenamento, carregamento e transformações |
| Algoritmo sem caminho compatível com GPU | Rever a biblioteca ou manter CPU |
| Treino compatível com GPU ocupa grande parte do ciclo | Executar um teste controlado na configuração candidata |
| Modelo grande ou alto volume de inferência | Medir memória, latência e concorrência com a carga real |
Compare tempo total até um resultado útil, e não apenas a execução de uma operação. Inclua instalação, transferência, treino, validação, armazenamento e períodos ociosos. Uma alternativa mais rápida por época pode ser pior se exigir mais tentativas para atingir a qualidade necessária.
Quando o projeto chegar a essa etapa, a Flatkey Cloud GPU permite avaliar opções de aluguel de GPUs NVIDIA. Confirme configuração, região, disponibilidade e condições para a carga pretendida. Leve o tamanho do conjunto, a biblioteca, a memória necessária e o objetivo do teste; este tutorial não exige contratar uma GPU para ser concluído.
Antes de colocar o modelo em uso
Defina o formato aceito de entrada, o comportamento para campos inválidos e como acompanhar erros após a publicação. Guarde a versão do modelo e a preparação dos dados juntas. Teste uma previsão com dados representativos fora do notebook antes de pensar em escala.
Se o próximo passo for servir um modelo de linguagem com infraestrutura própria, o guia de implantação do vLLM trata de outro tipo de carga. Não confunda um classificador tabular pequeno com a operação de um LLM: requisitos de memória, avaliação e servidor são diferentes.
Perguntas frequentes
Preciso de uma GPU para aprender machine learning com Python?
Não. O exemplo apresentado pode ser executado em CPU. Escolha infraestrutura maior quando existir um gargalo medido e uma implementação que possa aproveitá-la.
Por que usar uma referência básica antes de um modelo mais complexo?
Ela mostra o que é possível obter com uma regra simples. Isso permite avaliar se o modelo aprendeu algo útil e se a complexidade adicional é justificada.
A mesma semente garante o mesmo resultado em qualquer ambiente?
Ela fixa as escolhas aleatórias controladas por aquele parâmetro. Registre também versões e ambiente; diferenças de implementação e execução podem afetar resultados. Não confunda repetibilidade de uma divisão com garantia universal de desempenho.
Qual é o próximo projeto depois do Iris?
Escolha uma tarefa pequena com dados que você entende, um alvo verificável e um critério de sucesso. Repita o processo: referência, divisão correta, modelo, análise dos erros e medição. Esse hábito é a base para evoluir em machine learning com Python sem aumentar o custo antes da necessidade.
