Untitled
import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader, TensorDataset # 1. Funzione per caricare e preprocessare i dati def load_monk_dataset(file_path): """ Carica il dataset MONK dal file specificato e lo preprocessa. - file_path: Percorso del file del dataset. Ritorna: - X: Tensor con le feature. - y: Tensor con le label. """ features = [] labels = [] with open(file_path, 'r') as file: for line in file: parts = line.strip().split() labels.append(int(parts[0])) # La prima colonna è la label features.append([int(x) for x in parts[1:-1]]) # Le colonne successive sono le feature # Converte in tensori PyTorch X = torch.tensor(features, dtype=torch.float32) y = torch.tensor(labels, dtype=torch.long) return X, y # 2. Funzione per preparare i dati def prepare_data(X_train, y_train, X_test, y_test): """ Trasforma i dati di addestramento e test in tensori PyTorch, e li organizza in DataLoader per facilitarne la gestione in mini-batch. - X_train, y_train: Dati di addestramento (features e label). - X_test, y_test: Dati di test (features e label). Ritorna: - train_loader: DataLoader per i dati di addestramento. - test_loader: DataLoader per i dati di test. """ train_dataset = TensorDataset(X_train, y_train) test_dataset = TensorDataset(X_test, y_test) train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True) test_loader = DataLoader(test_dataset, batch_size=16, shuffle=False) return train_loader, test_loader # 3. Definizione della rete neurale class SimpleNN(nn.Module): """ Una rete neurale semplice con: - Un layer di input -> Hidden layer (ReLU) -> Output layer. """ def _init_(self, input_size, hidden_size, num_classes): super(SimpleNN, self)._init_() self.fc1 = nn.Linear(input_size, hidden_size) # Primo layer: da input a hidden self.relu = nn.ReLU() # Funzione di attivazione ReLU self.fc2 = nn.Linear(hidden_size, num_classes) # Secondo layer: da hidden a output def forward(self, x): """ Definisce come i dati passano attraverso la rete. - x: Input al modello. """ x = self.fc1(x) # Passa attraverso il primo layer x = self.relu(x) # Applica ReLU x = self.fc2(x) # Passa attraverso il secondo layer return x # 4. Funzione per addestrare il modello def train_model(model, train_loader, criterion, optimizer, epochs=10): """ Addestra il modello sui dati di training. - model: Rete neurale da addestrare. - train_loader: DataLoader per i dati di addestramento. - criterion: Funzione di perdita da minimizzare. - optimizer: Algoritmo di ottimizzazione (es. Adam). - epochs: Numero di epoche (cicli di addestramento). """ for epoch in range(epochs): model.train() total_loss = 0 for X_batch, y_batch in train_loader: optimizer.zero_grad() outputs = model(X_batch) loss = criterion(outputs, y_batch) loss.backward() optimizer.step() total_loss += loss.item() print(f"Epoch {epoch+1}/{epochs}, Loss: {total_loss:.4f}") # 5. Funzione per valutare il modello def evaluate_model(model, test_loader): """ Valuta il modello sui dati di test. - model: Rete neurale da valutare. - test_loader: DataLoader per i dati di test. """ 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, 1) total += y_batch.size(0) correct += (predicted == y_batch).sum().item() print(f"Accuracy: {correct / total * 100:.2f}%") # 6. Configurazione del modello input_size = 6 # Numero di feature nel dataset hidden_size = 10 # Numero di neuroni nel layer nascosto num_classes = 2 # Numero di classi (es. 0 e 1) learning_rate = 0.001 # Velocità di apprendimento # Inizializza il modello model = SimpleNN(input_size, hidden_size, num_classes) # Definisci la funzione di perdita criterion = nn.CrossEntropyLoss() # Definisci l'ottimizzatore optimizer = optim.Adam(model.parameters(), lr=learning_rate) # Carica i dati X_train, y_train = load_monk_dataset() X_test, y_test = load_monk_dataset() # Prepara i DataLoader train_loader, test_loader = prepare_data(X_train, y_train, X_test, y_test) # Addestra il modello train_model(model, train_loader, criterion, optimizer, epochs=20) # Valuta il modello evaluate_model(model, test_loader)
Leave a Comment