Explorando load_iris da Biblioteca Scikit-learn
Introdução
O Iris dataset é um conjunto de dados popular em Machine Learning que contém medições de diferentes características de três espécies de flores do gênero Iris (Iris-setosa, Iris-versicolor, e Iris-virginica). O conjunto é composto por 150 amostras de flores, cada uma com quatro características: comprimento e largura da sépala, e comprimento e largura da pétala. O objetivo clássico ao utilizar este conjunto de dados é prever a espécie da flor com base nas suas características.
A função load_iris do módulo sklearn.datasets carrega o dataset já formatado para ser utilizado em análises.
Estrutura do Dataset
Ao carregar o Iris dataset com o load_iris, o retorno é um objeto do tipo Bunch, que é semelhante a um dicionário. Ele contém os seguintes campos:
- data: Um array 2D (n_samples, n_features) que contém as características da flor.
- target: Um array 1D com as espécies correspondentes para cada amostra (0: setosa, 1: versicolor, 2: virginica).
- target_names: Uma lista com os nomes das espécies.
- feature_names: Uma lista com os nomes das características.
- DESCR: Uma descrição detalhada do dataset.
Exemplo Básico: Carregando o Iris Dataset
Aqui está como carregar o Iris dataset e explorar seus componentes básicos:
from sklearn.datasets import load_iris
# Carregar o dataset
iris = load_iris()
# Verificar as chaves do objeto Bunch
print(iris.keys())
# Mostrar as primeiras linhas das características (features)
print(iris.data[:5])
# Mostrar as espécies correspondentes (target)
print(iris.target[:5])
# Mostrar os nomes das características e espécies
print(iris.feature_names)
print(iris.target_names)
Exemplo 1: Convertendo para DataFrame Pandas
Para trabalhar mais facilmente com os dados, muitas vezes é útil convertê-los em um DataFrame do Pandas.
import pandas as pd
# Carregar o dataset
iris = load_iris()
# Converter para DataFrame
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['species'] = iris.target
# Mostrar as primeiras linhas
print(df.head())
Exemplo 2: Visualização de Dados com Seaborn
A visualização é uma parte importante da análise de dados. Podemos usar o Seaborn para criar gráficos de dispersão entre as características do Iris dataset.
import seaborn as sns
import matplotlib.pyplot as plt
# Carregar o dataset
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['species'] = iris.target
# Criar o gráfico de pares
sns.pairplot(df, hue='species', diag_kind='kde')
plt.show()
Exemplo 3: Separação de Dados para Treinamento e Teste
Uma prática comum em Machine Learning é dividir os dados em conjuntos de treinamento e teste para avaliar o desempenho dos modelos.
from sklearn.model_selection import train_test_split
# Separar os dados em treino e teste (80% treino, 20% teste)
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)
print(f'Tamanho do conjunto de treino: {X_train.shape}')
print(f'Tamanho do conjunto de teste: {X_test.shape}')
Exemplo 4: Treinando um Modelo de Regressão Logística
Vamos treinar um modelo de Regressão Logística para prever a espécie da flor com base em suas características.
from sklearn.linear_model import LogisticRegression
# Inicializar o modelo
model = LogisticRegression(max_iter=200)
# Treinar o modelo
model.fit(X_train, y_train)
# Fazer previsões no conjunto de teste
y_pred = model.predict(X_test)
print(f'Previsões: {y_pred}')
Exemplo 5: Avaliando o Modelo com Acurácia
Após o treinamento, podemos medir a acurácia do modelo no conjunto de teste.
from sklearn.metrics import accuracy_score
# Avaliar a acurácia
accuracy = accuracy_score(y_test, y_pred)
print(f'Acurácia: {accuracy * 100:.2f}%')
Exemplo 6: Exibindo a Matriz de Confusão
A matriz de confusão ajuda a visualizar o desempenho do modelo em termos de classificações corretas e incorretas.
from sklearn.metrics import confusion_matrix
import seaborn as sns
# Calcular a matriz de confusão
conf_matrix = confusion_matrix(y_test, y_pred)
# Visualizar a matriz de confusão
sns.heatmap(conf_matrix, annot=True, cmap='Blues', fmt='d')
plt.xlabel('Previsão')
plt.ylabel('Real')
plt.show()
Exemplo 7: Aplicando K-Nearest Neighbors (KNN)
Vamos utilizar um modelo de K-Nearest Neighbors para classificação.
from sklearn.neighbors import KNeighborsClassifier
# Inicializar o modelo com 3 vizinhos
knn = KNeighborsClassifier(n_neighbors=3)
# Treinar o modelo
knn.fit(X_train, y_train)
# Fazer previsões no conjunto de teste
y_pred_knn = knn.predict(X_test)
# Avaliar a acurácia
accuracy_knn = accuracy_score(y_test, y_pred_knn)
print(f'Acurácia com KNN: {accuracy_knn * 100:.2f}%')
Exemplo 8: Redução de Dimensionalidade com PCA
Podemos usar a Análise de Componentes Principais (PCA) para reduzir a dimensionalidade dos dados e visualizá-los em um espaço 2D.
from sklearn.decomposition import PCA
# Inicializar o PCA para reduzir para 2 componentes
pca = PCA(n_components=2)
# Ajustar e transformar os dados
X_pca = pca.fit_transform(iris.data)
# Visualizar em 2D
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=iris.target, cmap='viridis')
plt.xlabel('Componente Principal 1')
plt.ylabel('Componente Principal 2')
plt.title('PCA no Iris Dataset')
plt.show()
Exemplo 9: Validação Cruzada
A validação cruzada é usada para garantir que o modelo não esteja sobreajustado (overfitting) aos dados de treino.
from sklearn.model_selection import cross_val_score
# Aplicar validação cruzada com 5 folds
scores = cross_val_score(LogisticRegression(max_iter=200), iris.data, iris.target, cv=5)
# Exibir as acurácias de cada fold
print(f'Acurácias em cada fold: {scores}')
print(f'Média das acurácias: {scores.mean() * 100:.2f}%')
Exemplo 10: Random Forest Classifier
Um modelo mais robusto como Random Forest pode ser utilizado para aumentar a precisão.
from sklearn.ensemble import RandomForestClassifier
# Inicializar o modelo de Random Forest
rf = RandomForestClassifier(n_estimators=100, random_state=42)
# Treinar o modelo
rf.fit(X_train, y_train)
# Fazer previsões no conjunto de teste
y_pred_rf = rf.predict(X_test)
# Avaliar a acurácia
accuracy_rf = accuracy_score(y_test, y_pred_rf)
print(f'Acurácia com Random Forest: {accuracy_rf * 100:.2f}%')
Conclusão
O load_iris é uma função conveniente que carrega o famoso Iris dataset diretamente na estrutura necessária para realizar diversas tarefas de Machine Learning. Com exemplos que variam desde a análise exploratória de dados até a utilização de algoritmos de classificação avançados, este dataset é ideal para iniciantes e para ilustrar conceitos essenciais.
edvaldo b. guimarães filho 
Leave a comment