==========================================
CLASSIFICAÇÃO DO IRIS COM PYTORCH
Arquitetura:
Entrada(3) -> Linear(6) -> ReLU -> Linear(3)
==========================================
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from torch.utils.data import TensorDataset, DataLoader
------------------------------------------
1) Carregar dataset Iris
------------------------------------------
iris = load_iris()
Usar apenas 3 atributos, como pedido no exercício
X = iris.data[:, :3]
y = iris.target
------------------------------------------
2) Dividir em treino e teste
------------------------------------------
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
------------------------------------------
3) Converter para tensores
------------------------------------------
X_train = torch.FloatTensor(X_train)
X_test = torch.FloatTensor(X_test)
y_train = torch.LongTensor(y_train)
y_test = torch.LongTensor(y_test)
------------------------------------------
4) Criar DataLoaders
------------------------------------------
train_data = TensorDataset(X_train, y_train)
test_data = TensorDataset(X_test, y_test)
train_loader = DataLoader(train_data, batch_size=16, shuffle=True)
test_loader = DataLoader(test_data, batch_size=16, shuffle=False)
==========================================
5) MODELO COM nn.Sequential
==========================================
model_seq = nn.Sequential(
nn.Linear(3, 6), # 3 entradas -> 6 neurônios ocultos
nn.ReLU(), # ativação
nn.Linear(6, 3) # 6 ocultos -> 3 classes
)
print("Modelo Sequential:")
print(model_seq)
==========================================
6) MODELO COM nn.Module
==========================================
class IrisNet(nn.Module):
def init(self):
super().init()
self.hidden = nn.Linear(3, 6)
self.relu = nn.ReLU()
self.output = nn.Linear(6, 3)
def forward(self, x):
x = self.hidden(x)
x = self.relu(x)
x = self.output(x)
return x
model_mod = IrisNet()
print("\nModelo Module:")
print(model_mod)
------------------------------------------
7) Escolher qual modelo treinar
------------------------------------------
model = model_mod # troque para model_seq se quiser
------------------------------------------
8) Loss e otimizador
------------------------------------------
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
==========================================
9) Treinamento
==========================================
for epoch in range(30):
model.train()
total_loss = 0
for X_batch, y_batch in train_loader:
# Forward
outputs = model(X_batch)
loss = criterion(outputs, y_batch)
# Backprop
optimizer.zero_grad()
loss.backward()
optimizer.step()
total_loss += loss.item()
print(f"Época {epoch+1:02d} | Loss: {total_loss:.4f}")
==========================================
10) Avaliação
==========================================
model.eval()
correct = 0
total = 0
with torch.no_grad():
for X_batch, y_batch in test_loader:
outputs = model(X_batch)
_, predicted = torch.max(outputs, dim=1)
total += y_batch.size(0)
correct += (predicted == y_batch).sum().item()
accuracy = 100 * correct / total
print(f"\nAcurácia no teste: {accuracy:.2f}%")
==========================================
11) Exemplo de predição
==========================================
sample = X_test[0].unsqueeze(0)
with torch.no_grad():
output = model(sample)
pred = torch.argmax(output, dim=1).item()
print("\nExemplo:")
print("Entrada:", sample)
print("Classe prevista:", pred)
print("Classe real:", y_test[0].item())
