Importante

Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!

1
resposta

Mão na massa: construindo um classificador com o dataset Iris

import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
iris = load_iris()
df = pd.DataFrame(
iris.data,
columns=iris.feature_names
)
df["species"] = iris.target
df["species"] = df["species"].map({
0: "setosa",
1: "versicolor",
2: "virginica"
})

print("Primeiras linhas do dataset:")
print(df.head())

print("\nInformações gerais:")
print(df.info())

print("\nEstatísticas descritivas:")
print(df.describe())
X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(
X,
y,
test_size=0.30,
random_state=42,
stratify=y
)

print("\nQuantidade de amostras para treino:", len(X_train))
print("Quantidade de amostras para teste:", len(X_test))
modelo = DecisionTreeClassifier(random_state=42)
modelo.fit(X_train, y_train)

print("\nModelo treinado com sucesso!")
y_pred = modelo.predict(X_test)
acuracia = accuracy_score(y_test, y_pred)

print(f"\nAcurácia do modelo: {acuracia:.2%}")

print("\nRelatório de Classificação:")
print(classification_report(
y_test,
y_pred,
target_names=iris.target_names
))

print("\nMatriz de Confusão:")
print(confusion_matrix(y_test, y_pred))
scores = cross_val_score(
modelo,
X,
y,
cv=5
)

print("\nResultados da Validação Cruzada:")
print(scores)

print(f"\nAcurácia Média: {scores.mean():.2%}")
print(f"Desvio Padrão: {scores.std():.4f}")
novas_flores = [
[5.1, 3.5, 1.4, 0.2],
[6.0, 2.9, 4.5, 1.5],
[6.7, 3.0, 5.8, 2.2]
]

previsoes = modelo.predict(novas_flores)

print("\nClassificação de novas flores:")

for i, pred in enumerate(previsoes):
especie = iris.target_names[pred]
print(f"Flor {i+1}: {especie}")

Primeiras linhas do dataset:
sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)
0 5.1 3.5 1.4 0.2
1 4.9 3.0 1.4 0.2
2 4.7 3.2 1.3 0.2
3 4.6 3.1 1.5 0.2
4 5.0 3.6 1.4 0.2

species
0 setosa
1 setosa
2 setosa
3 setosa
4 setosa

Informações gerais:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 150 entries, 0 to 149
Data columns (total 5 columns):

Column Non-Null Count Dtype


0 sepal length (cm) 150 non-null float64
1 sepal width (cm) 150 non-null float64
2 petal length (cm) 150 non-null float64
3 petal width (cm) 150 non-null float64
4 species 150 non-null object
dtypes: float64(4), object(1)
memory usage: 6.0+ KB
None

Estatísticas descritivas:
sepal length (cm) sepal width (cm) petal length (cm)
count 150.000000 150.000000 150.000000
mean 5.843333 3.057333 3.758000
std 0.828066 0.435866 1.765298
min 4.300000 2.000000 1.000000
25% 5.100000 2.800000 1.600000
50% 5.800000 3.000000 4.350000
75% 6.400000 3.300000 5.100000
max 7.900000 4.400000 6.900000

   petal width (cm)  

count 150.000000
mean 1.199333
std 0.762238
min 0.100000
25% 0.300000
50% 1.300000
75% 1.800000
max 2.500000

Quantidade de amostras para treino: 105
Quantidade de amostras para teste: 45

Modelo treinado com sucesso!

Acurácia do modelo: 93.33%

Relatório de Classificação:
precision recall f1-score support

  setosa       1.00      1.00      1.00        15

versicolor 1.00 0.80 0.89 15
virginica 0.83 1.00 0.91 15

accuracy                           0.93        45

macro avg 0.94 0.93 0.93 45
weighted avg 0.94 0.93 0.93 45

Matriz de Confusão:
[[15 0 0]
[ 0 12 3]
[ 0 0 15]]

Resultados da Validação Cruzada:
[0.96666667 0.96666667 0.9 0.93333333 1. ]

Acurácia Média: 95.33%
Desvio Padrão: 0.0340

Classificação de novas flores:
Flor 1: setosa
Flor 2: versicolor
Flor 3: virginica

1 resposta

Olá, Marcelo. Como vai?

Excelente execução da atividade prática! O dataset Iris é o clássico mais famoso do Machine Learning para entender problemas de classificação, e o seu código cobriu todas as etapas cruciais de análise, treinamento e validação.

Analisando os resultados gerados pelas suas saídas, separei alguns pontos técnicos fundamentais para enriquecer o seu estudo e a interpretação desse modelo:

1. Boa Prática no train_test_split

Você utilizou o parâmetro stratify=y. Isso foi uma excelente escolha! Em conjuntos de dados pequenos como o Iris (150 registros equilibrados), a amostragem estratificada garante que o treino e o teste mantenham exatamente a mesma proporção de cada espécie de flor (15 amostras de cada no teste). Sem isso, o modelo correria o risco de testar menos amostras de uma espécie específica, enviesando a acurácia.

2. Leitura da Matriz de Confusão

A sua acurácia de teste foi de 93.33%. Olhando para a sua Matriz de Confusão, conseguimos identificar exatamente onde o modelo errou:

[[15  0  0]  -> Setosa (15 acertos, 0 erros)
 [ 0 12  3]  -> Versicolor (12 acertos, 3 erros classificados como Virginica)
 [ 0  0 15]] -> Virginica (15 acertos, 0 erros)

Perceba que a classe setosa é linearmente separável, o que faz o modelo atingir 100% de precisão nela facilmente. O desafio real reside na fronteira entre versicolor e virginica. O seu modelo classificou incorretamente 3 flores versicolor como se fossem virginica.

3. Validação Cruzada (Cross-Validation)

A sua validação cruzada retornou uma acurácia média de 95.33% com um desvio padrão baixo (0.0340).

  • O que isso significa? Significa que o seu classificador é bastante estável. O desvio padrão baixo indica que a capacidade de acerto do algoritmo não varia de forma drástica dependendo de como os dados são divididos, confirmando que o modelo possui uma boa capacidade de generalização e não sofreu de overfitting agudo.

4. Indo além: Exportando a Árvore de Decisão

Uma das maiores vantagens do algoritmo DecisionTreeClassifier é que ele é uma "caixa branca", ou seja, é totalmente visualizável. Como sugestão para complementar o seu projeto, você pode renderizar a árvore para ver quais regras de corte (if/else) o modelo criou para classificar as novas flores.

Basta adicionar esse trecho após o treinamento:

from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 8))
plot_tree(
    modelo,
    feature_names=iris.feature_names,
    class_names=iris.target_names,
    filled=True
)
plt.show()

Parabéns pela dedicação e pela organização do código! Você estruturou o script de maneira impecável.

Espero que possa ter lhe ajudado!