Como treinar um modelo de classificação com scikit-learn

Treinar um modelo de classificação é o coração do Machine Learning: é o passo em que o algoritmo aprende a partir de exemplos para depois prever a categoria de novos dados. Com a biblioteca scikit-learn, em Python, consegues treinar um primeiro modelo em poucas linhas. Este guia mostra o caminho completo, do carregamento dos dados até à primeira previsão e à sua avaliação.

Pré-requisitos

• Python 3 instalado no teu computador.
• A biblioteca scikit-learn instalada. Se ainda não a tens, corre pip install scikit-learn no terminal.
• Conhecimentos básicos de Python: variáveis e como correr um script.
• Não precisas de descarregar nada: usamos um conjunto de dados que já vem incluído no scikit-learn.

Passo 1: Carregar os dados

Para este exemplo usamos o dataset Iris, um clássico para aprender classificação. Contém as medidas de 150 flores divididas em três espécies, e o objetivo do modelo será prever a espécie a partir dessas medidas.

from sklearn.datasets import load_iris

iris = load_iris()
X = iris.data        # as medidas (4 colunas por flor)
y = iris.target      # a especie: 0, 1 ou 2

print(X.shape)             # (150, 4)
print(iris.target_names)   # ['setosa' 'versicolor' 'virginica']

Guardamos as características (as medidas) em X e a resposta certa (a espécie) em y. Em Machine Learning é convenção chamar X aos dados de entrada e y àquilo que queremos prever.

Passo 2: Dividir em treino e teste

Antes de treinar, separamos os dados em duas partes: uma para o modelo aprender (treino) e outra para verificar se aprendeu bem (teste). Assim medimos o desempenho em dados que o modelo nunca viu, o que é essencial para confiar no resultado.

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, stratify=y
)

Reservámos 20% dos dados para teste com test_size=0.2. O random_state=42 garante que a divisão é sempre igual quando voltas a correr o código, e stratify=y mantém a mesma proporção de espécies em cada parte.

Passo 3: Escolher e treinar o modelo

Vamos usar a regressão logística, um modelo simples e muito popular para classificação. Treinar significa chamar o método fit(), que ajusta o modelo aos dados de treino, isto é, encontra o padrão que liga as medidas à espécie.

from sklearn.linear_model import LogisticRegression

modelo = LogisticRegression(max_iter=1000)
modelo.fit(X_train, y_train)

É só isto: numa linha criamos o modelo e noutra treinamo-lo. Usamos max_iter=1000 para dar ao algoritmo iterações suficientes para convergir e evitar um aviso de convergência. Depois do fit(), o modelo já aprendeu e está pronto a prever.

Passo 4: Fazer previsões

Com o modelo treinado, pedimos-lhe que preveja a espécie das flores do conjunto de teste, usando o método predict().

previsoes = modelo.predict(X_test)

print(previsoes[:5])     # ex.: [1 0 2 1 1]

Cada número é a espécie que o modelo previu para uma flor. Ao comparar estas previsões com as respostas reais (y_test), conseguimos saber se o modelo é bom.

Verificar o resultado

A forma mais direta de avaliar é medir a exatidão (accuracy): a percentagem de previsões corretas no conjunto de teste.

from sklearn.metrics import accuracy_score

exatidao = accuracy_score(y_test, previsoes)
print(f"Exatidao: {exatidao:.2f}")

Neste exemplo deves obter um valor à volta de 0.97, ou seja, o modelo acerta em cerca de 97% das flores de teste (o valor exato pode variar ligeiramente). Um número alto e próximo de 1 indica que o teu primeiro modelo está a funcionar.

Dica: a exatidão sozinha nem sempre chega. Quando as classes estão desequilibradas, vale a pena olhar também para a matriz de confusão e para métricas como precisão e recall.

Conclusão

Acabaste de treinar um modelo de classificação de ponta a ponta: carregaste os dados, dividiste-os, treinaste com fit() e avaliaste as previsões. A partir daqui podes experimentar outros modelos, como DecisionTreeClassifier ou RandomForestClassifier, trocando apenas uma linha de código, ou aprofundar a avaliação com uma matriz de confusão. Fica o desafio: consegues melhorar a exatidão usando um modelo diferente com os mesmos dados?