From b8fb366bf533291589e0f02e2853d7d880bfe284 Mon Sep 17 00:00:00 2001 From: arman Date: Fri, 14 Feb 2025 23:53:03 +0100 Subject: [PATCH] subset aktualisiert+plot --- cnn_bootstrap_agg.py | 116 ++++++++++++++++++++++++++++++++----------- 1 file changed, 87 insertions(+), 29 deletions(-) diff --git a/cnn_bootstrap_agg.py b/cnn_bootstrap_agg.py index 880f207..d53036a 100644 --- a/cnn_bootstrap_agg.py +++ b/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_targets.extend(targets.detach().cpu().numpy()) + all_train_preds.extend(outputs.detach().cpu().numpy()) + all_train_targets.extend(targets.detach().cpu().numpy()) - r2 = r2_score(all_targets, all_preds) - print(f"Epoch {epoch+1}/{epochs}, Loss: {total_loss/len(dataloader):.4f}, R^2: {r2:.4f}") + train_r2 = r2_score(all_train_targets, all_train_preds) + 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 - 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 - - + return models, all_histories 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))