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)