Redes neurais (2#) - Iniciando com Iris Dataset e Python

Neste post, exploraremos como criar uma rede neural simples utilizando Python e a biblioteca TensorFlow com o conjunto de dados Iris Dataset.

O conjunto de dados Iris Dataset

Vamos criar um modelo preditivo utilizando o Iris Dataset.

O Iris Dataset é um conjunto de dados clássico na área de aprendizado de máquina, amplamente utilizado para ensino, aprendizado e benchmarking de algoritmos. Foi introduzido por Ronald Fisher em 1936 em seu artigo “The Use of Multiple Measurements in Taxonomic Problems”. Veja nda Figura 1 destacado o que é uma sépala (sepal) e o que é uma pétala (petal) de uma flor.

Figura 1 - Imagem de uma flor

Fonte: https://www.sakurai.dev.br/classificacao-iris/ apud https://www.datacamp.com/tutorial/machine-learning-in-r

O Iris Dataset contém informações sobre 150 amostras de flores de íris pertencentes a três espécies diferentes:

• Iris setosa

• Iris versicolor

• Iris virginica

Cada amostra é caracterizada por quatro atributos medidos em centímetros:

1. Sepal length (comprimento da sépala)

2. Sepal width (largura da sépala)

3. Petal length (comprimento da pétala)

4. Petal width (largura da pétala)

Além disso, o dataset inclui a classe da flor (a espécie a que pertence).

Uma versão do Iris Dataset pode ser encontrada para download no Hugging Face. Veja na Figura 2 um exemplo dos dados.

Figura 2 - Exemplo de visualização do Iris Dataset no Hugging Face

Fonte: Giseldo Neo (2025)

O conjunto de dados é composto por:

• Entradas: 4 características numéricas (atributos contínuos)

• Saída: Classe categórica representando a espécie da flor (3 classes)

Exemplo de entrada:

---

Propriedades Importantes do Iris Datasets

1. Balanceamento: O dataset é balanceado, com 50 amostras para cada espécie.

2. Linearmente separável: A classe Iris setosa é completamente separável das outras duas espécies com base nos atributos medidos.

3. Simples e pequeno: É ideal para demonstrar algoritmos de classificação, pois possui apenas 150 amostras e 4 características.

Construindo uma Rede Neural com Python

Vamos criar uma rede neural simples para resolver um problema clássico de classificação: o conjunto de dados Iris, que contém informações sobre flores de três espécies.

Antes de começarmos, certifique-se de ter o TensorFlow instalado. Se ainda não o possui, instale usando:

pip install tensorflow

Ou Utilize o Colab do Google, ele já vem com o tensorflow instalado.

Importação das Bibliotecas

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder

Carregando e Preparando os Dados

# Carregar o conjunto de dados
iris = load_iris()
X = iris.data
y = iris.target.reshape(-1, 1)

# Codificar as classes como vetores one-hot
encoder = OneHotEncoder(sparse_output=False)
y = encoder.fit_transform(y)

# Dividir os dados em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Criando o Modelo

# Definir o modelo sequencial
model = Sequential([
    Dense(10, activation='relu', input_shape=(X.shape[1],)),  # Camada oculta com 10 neurônios
    Dense(10, activation='relu'),                             # Outra camada oculta
    Dense(y.shape[1], activation='softmax')                   # Camada de saída
])

Compilando e Treinando o Modelo

# Compilar o modelo
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Treinar o modelo
history = model.fit(X_train, y_train, epochs=50, validation_data=(X_test, y_test))

Avaliando o Modelo

# Avaliar o modelo no conjunto de teste
loss, accuracy = model.evaluate(X_test, y_test)
print(f"Acurácia no conjunto de teste: {accuracy:.2f}")

Visualizando o Desempenho

Podemos plotar os gráficos de perda e acurácia ao longo das épocas para entender o comportamento do modelo.

import matplotlib.pyplot as plt

# Gráfico de perda
plt.plot(history.history['loss'], label='Treino')
plt.plot(history.history['val_loss'], label='Validação')
plt.title('Perda ao longo das épocas')
plt.xlabel('Épocas')
plt.ylabel('Perda')
plt.legend()
plt.show()

# Gráfico de acurácia
plt.plot(history.history['accuracy'], label='Treino')
plt.plot(history.history['val_accuracy'], label='Validação')
plt.title('Acurácia ao longo das épocas')
plt.xlabel('Épocas')
plt.ylabel('Acurácia')
plt.legend()
plt.show()

Conclusão

Com algumas linhas de código, criamos e treinamos uma rede neural simples para resolver um problema de classificação. Essa base pode ser expandida para problemas mais complexos, como detecção de objetos ou análise de sentimentos.

O TensorFlow e outras bibliotecas, como PyTorch e scikit-learn, tornam o processo de construção e treinamento de redes neurais acessível até para iniciantes.