subset aktualisiert+plot

cnn_bootstrap_agg.py

@@ -13,17 +13,19 @@ from EarlyStopping import EarlyStopping
 import torch.optim as optim
 from torch.utils.data import DataLoader, Dataset, Subset  # Import Subset
 #from utils import tokenize_and_pad, HumorDataset, evaluate_model, bootstrap_aggregation
+def train_model(model, train_dataset, val_dataset, criterion, optimizer, epochs, batch_size):
+    train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+    val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False)
 
-def train_model(model, train_dataset, criterion, optimizer, epochs, batch_size):
-    dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
     model.to(device)
+    history = {'train_loss': [], 'val_loss': [], 'train_r2': [], 'val_r2': []}
 
     for epoch in range(epochs):
         model.train()
         total_loss = 0
-        all_preds, all_targets = [], []
+        all_train_preds, all_train_targets = [], []
 
-        for inputs, targets in dataloader:
+        for inputs, targets in train_dataloader:
             inputs, targets = inputs.to(device), targets.to(device)
             optimizer.zero_grad()
             outputs = model(inputs).squeeze()
@@ -32,44 +34,67 @@ def train_model(model, train_dataset, criterion, optimizer, epochs, batch_size):
             optimizer.step()
             total_loss += loss.item()
 
-            all_preds.extend(outputs.detach().cpu().numpy())
+            all_train_preds.extend(outputs.detach().cpu().numpy())
-            all_targets.extend(targets.detach().cpu().numpy())
+            all_train_targets.extend(targets.detach().cpu().numpy())
 
-        r2 = r2_score(all_targets, all_preds)
+        train_r2 = r2_score(all_train_targets, all_train_preds)
-        print(f"Epoch {epoch+1}/{epochs}, Loss: {total_loss/len(dataloader):.4f}, R^2: {r2:.4f}")
+        train_loss = total_loss / len(train_dataloader)
+        history['train_loss'].append(train_loss)
+        history['train_r2'].append(train_r2)
 
-def bootstrap_aggregation(ModelClass, train_dataset, num_models=5, epochs=10, batch_size=32, learning_rate=0.001):
+        # **Validierung nach jeder Epoche**
+        model.eval()
+        val_loss = 0
+        all_val_preds, all_val_targets = [], []
+
+        with torch.no_grad():
+            for inputs, targets in val_dataloader:
+                inputs, targets = inputs.to(device), targets.to(device)
+                outputs = model(inputs).squeeze()
+                loss = criterion(outputs, targets)
+                val_loss += loss.item()
+
+                all_val_preds.extend(outputs.cpu().numpy())
+                all_val_targets.extend(targets.cpu().numpy())
+
+        val_r2 = r2_score(all_val_targets, all_val_preds)
+        val_loss /= len(val_dataloader)
+        history['val_loss'].append(val_loss)
+        history['val_r2'].append(val_r2)
+
+        print(f"Epoch {epoch+1}/{epochs}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}, Train R²: {train_r2:.4f}, Val R²: {val_r2:.4f}")
+
+    return history  # **Gibt die Verlaufsdaten zurück**
+
+
+def bootstrap_aggregation(ModelClass, train_dataset, num_models=3, epochs=5, batch_size=32, learning_rate=0.001):
     models = []
-    all_r2_scores, all_mse_scores, all_mae_scores = [], [], []
+    all_histories = []  # **Speichert Trainingsverlauf aller Modelle**
+
+    subset_size = len(train_dataset) // num_models
 
     for i in range(num_models):
         print(f"Training Model {i+1}/{num_models}...")
-        subset_indices = np.random.choice(len(train_dataset), len(train_dataset), replace=True)
+
+        start_idx = i * subset_size
+        end_idx = start_idx + subset_size
+        subset_indices = list(range(0, start_idx)) + list(range(end_idx, len(train_dataset)))
+
         subset = Subset(train_dataset, subset_indices)
 
+        # **Validierungsdaten als restliche Daten**
+        val_indices = list(range(start_idx, end_idx))
+        val_subset = Subset(train_dataset, val_indices)
+
         model = ModelClass()
         criterion = nn.MSELoss()
         optimizer = optim.Adam(model.parameters(), lr=learning_rate)
 
-        train_model(model, subset, criterion, optimizer, epochs, batch_size)
+        history = train_model(model, subset, val_subset, criterion, optimizer, epochs, batch_size)
+        all_histories.append(history)  # **Speichere Verlaufsdaten**
         models.append(model)
 
-        # Performance evaluieren
+    return models, all_histories
-        predictions = ensemble_predict([model], HumorDataset(test_input_ids, test_labels))
-
-        mse = mean_squared_error(test_labels.numpy(), predictions)
-        mae = mean_absolute_error(test_labels.numpy(), predictions)
-        r2 = r2_score(test_labels.numpy(), predictions)
-
-        all_mse_scores.append(mse)
-        all_mae_scores.append(mae)
-        all_r2_scores.append(r2)
-
-        print(f"Model {i+1}: MSE = {mse:.4f}, MAE = {mae:.4f}, Test-R² = {r2:.4f}\n")
-
-    return models
-
-
 
 def ensemble_predict(models, test_dataset):
     dataloader = DataLoader(test_dataset, batch_size=32, shuffle=False)
@@ -84,6 +109,36 @@ def ensemble_predict(models, test_dataset):
 
     return np.array(all_predictions)
 
+import matplotlib.pyplot as plt
+
+def plot_training_histories(histories, num_models):
+    epochs = range(1, len(histories[0]['train_loss']) + 1)
+
+    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
+
+    # **Links: Trainings- und Validierungsverlust**
+    for i in range(num_models):
+        axes[0].plot(epochs, histories[i]['train_loss'], label=f"Train Loss Model {i+1}")
+        axes[0].plot(epochs, histories[i]['val_loss'], linestyle='dashed', label=f"Val Loss Model {i+1}")
+
+    axes[0].set_title("Train & Validation Loss")
+    axes[0].set_xlabel("Epochs")
+    axes[0].set_ylabel("Loss")
+    axes[0].legend()
+
+    # **Rechts: R²-Werte für Training und Validierung**
+    for i in range(num_models):
+        axes[1].plot(epochs, histories[i]['train_r2'], label=f"Train R² Model {i+1}")
+        axes[1].plot(epochs, histories[i]['val_r2'], linestyle='dashed', label=f"Val R² Model {i+1}")
+
+    axes[1].set_title("Train & Validation R² Score")
+    axes[1].set_xlabel("Epochs")
+    axes[1].set_ylabel("R² Score")
+    axes[1].legend()
+
+    plt.show()
+
+
 
 # 1. Gerät automatisch erkennen
 device = torch.device('mps' if torch.backends.mps.is_available()
@@ -163,7 +218,7 @@ def create_cnn(vocab_size, embed_dim, embedding_matrix):
     return CNNRegressor(vocab_size, embed_dim, embedding_matrix)
 
 # 8. Bootstrap Aggregation mit CNN
-models = bootstrap_aggregation(
+models, histories = bootstrap_aggregation(
     lambda: create_cnn(vocab_size, d_model, embedding_matrix),
     dataset,
     num_models=5,
@@ -171,6 +226,9 @@ models = bootstrap_aggregation(
     batch_size=32,
     learning_rate=0.001
 )
+# **Plot Training & Validation Loss & R²**
+plot_training_histories(histories, num_models=5)
+
 
 # Vorhersagen mit Ensemble
 predictions = ensemble_predict(models, HumorDataset(test_input_ids, test_labels))