From d9103d1ec15c64fcf3fa7692eb9d5f3cc8cb63a1 Mon Sep 17 00:00:00 2001 From: Nils <1826514@stud.hs-mannheim.de> Date: Sat, 15 Feb 2025 13:22:49 +0100 Subject: [PATCH 1/4] removed Main and transfered to notebook --- BertFine.ipynb | 417 +++++++++++++++++++++++++++++++++++++++++++++++ bert_no_ernie.py | 222 +++++++++++++++---------- 2 files changed, 552 insertions(+), 87 deletions(-) create mode 100644 BertFine.ipynb diff --git a/BertFine.ipynb b/BertFine.ipynb new file mode 100644 index 0000000..b70d900 --- /dev/null +++ b/BertFine.ipynb @@ -0,0 +1,417 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Notebook Fine-Tuning Bert\n", + "In diesem Notebook wird Bert bzw. 'BertForSequenceClassification' feingetuned.
\n", + "Funktionen werden aus diesem [Skript](bert_no_ernie.py) geladen." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from bert_no_ernie import *\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rohdaten einlesen\n", + "An dieser Stelle, wird der Hackathon Datensatz eingelesen welcher Annotierte Daten enthält.\n", + "Die wichtigsten Attribute dieses Datensatzes in diesem sind *Text* (welcher den \"Witz\" als String enthält) und *is_humor* (ein durch 0 und 1 dargestellter Wahrheitswert) welcher angibt ob der entsprechende Text in der Zeile ein Witz ist oder nicht." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idtextis_humorhumor_ratinghumor_controversyoffense_rating
01TENNESSEE: We're the best state. Nobody even c...12.421.00.2
12A man inserted an advertisement in the classif...12.501.01.1
23How many men does it take to open a can of bee...11.950.02.4
34Told my mom I hit 1200 Twitter followers. She ...12.111.00.0
45Roses are dead. Love is fake. Weddings are bas...12.780.00.1
\n", + "
" + ], + "text/plain": [ + " id text is_humor \\\n", + "0 1 TENNESSEE: We're the best state. Nobody even c... 1 \n", + "1 2 A man inserted an advertisement in the classif... 1 \n", + "2 3 How many men does it take to open a can of bee... 1 \n", + "3 4 Told my mom I hit 1200 Twitter followers. She ... 1 \n", + "4 5 Roses are dead. Love is fake. Weddings are bas... 1 \n", + "\n", + " humor_rating humor_controversy offense_rating \n", + "0 2.42 1.0 0.2 \n", + "1 2.50 1.0 1.1 \n", + "2 1.95 0.0 2.4 \n", + "3 2.11 1.0 0.0 \n", + "4 2.78 0.0 0.1 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = pd.read_csv(\"data/hack.csv\")\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#Hyperparameter festlegen. Und Zufall seeden\n", + "# Set Max Epoch Amount\n", + "EPOCH = 10\n", + "# DROPOUT-PROBABILITY\n", + "DROPOUT = 0.1\n", + "# BATCHSIZE\n", + "BATCH_SIZE = 16\n", + "#LEARNING RATE\n", + "LEARNING_RATE = 1e-5\n", + "# RANDOM SEED\n", + "RNDM_SEED = 501\n", + "# FREEZE Bert Layers\n", + "FREEZE = True\n", + "\n", + "torch.manual_seed(RNDM_SEED)\n", + "np.random.seed(RNDM_SEED)\n", + "torch.cuda.manual_seed_all(RNDM_SEED)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Tokenizer für Bert Model laden.\n", + "tokenizer = AutoTokenizer.from_pretrained(\"google-bert/bert-base-uncased\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Daten aufteilen(70/15/15) und an Custom Dataset Klasse übergeben\n", + "train_data,test_data,val_data = create_datasets(tokenizer,df,.7,True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# DataLoaders basierend auf Datasets kreieren.\n", + "train_loader, test_loader, validation_loader = create_dataloaders([train_data,test_data,val_data],batchsize=BATCH_SIZE,shufflelist=[True,True,False])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-uncased and are newly initialized: ['classifier.bias', 'classifier.weight']\n", + "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n" + ] + } + ], + "source": [ + "# Model instanziieren, sowie Loss-Funktion und Optimizer\n", + "mybert = CustomBert(DROPOUT)\n", + "mybert.to(DEVICE)\n", + "\n", + "criterion = nn.CrossEntropyLoss()\n", + "optimizer = optim.Adam(mybert.parameters(), lr = LEARNING_RATE)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For 1 the Scores are: \n", + "Training Loss is 0.6827\n", + "Validation Loss: 0.6828 ### Validation Accuracy 60.8333%\n", + "For 2 the Scores are: \n", + "Training Loss is 0.6836\n", + "Validation Loss: 0.6825 ### Validation Accuracy 60.8333%\n", + "For 3 the Scores are: \n", + "Training Loss is 0.6824\n", + "Validation Loss: 0.6821 ### Validation Accuracy 60.8333%\n", + "For 4 the Scores are: \n", + "Training Loss is 0.6815\n", + "Validation Loss: 0.6817 ### Validation Accuracy 60.8333%\n", + "For 5 the Scores are: \n", + "Training Loss is 0.6808\n", + "Validation Loss: 0.6814 ### Validation Accuracy 60.8333%\n", + "For 6 the Scores are: \n", + "Training Loss is 0.6809\n", + "Validation Loss: 0.6810 ### Validation Accuracy 60.8333%\n", + "For 7 the Scores are: \n", + "Training Loss is 0.6801\n", + "Validation Loss: 0.6807 ### Validation Accuracy 60.7500%\n", + "For 8 the Scores are: \n", + "Training Loss is 0.6795\n", + "Validation Loss: 0.6804 ### Validation Accuracy 60.7500%\n", + "For 9 the Scores are: \n", + "Training Loss is 0.6797\n", + "Validation Loss: 0.6801 ### Validation Accuracy 60.7500%\n", + "For 10 the Scores are: \n", + "Training Loss is 0.6793\n", + "Validation Loss: 0.6799 ### Validation Accuracy 60.7500%\n" + ] + } + ], + "source": [ + "# Trainings - und Validierungs Durchgänge\n", + "loss_vals, eval_vals = np.zeros(EPOCH), np.zeros(EPOCH)\n", + "\n", + "for epoch in range(EPOCH):\n", + " print(f\"For {epoch+1} the Scores are: \")\n", + " loss_vals[epoch] = training_loop(mybert,optimizer=optimizer,criterion=criterion,train_loader=train_loader,freeze_bert=FREEZE)\n", + " eval_vals[epoch] = eval_loop(mybert,criterion=criterion,validation_loader=validation_loader) " + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.68267711, 0.68355761, 0.68237029, 0.68148399, 0.68079539,\n", + " 0.68086683, 0.68012043, 0.67948493, 0.67972843, 0.67932365])" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "array([0.68283186, 0.68245001, 0.68208028, 0.68170239, 0.68136094,\n", + " 0.68103237, 0.68071597, 0.68041458, 0.68011246, 0.67985092])" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "display(loss_vals)\n", + "display(eval_vals)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "def test_loop(model:CustomBert, test_loader:DataLoader):\n", + " test_accuracy = np.zeros(len(test_loader))\n", + " for index,batch in enumerate(test_loader):\n", + " input_ids, att_mask, labels = batch.values()\n", + " input_ids, att_mask, labels = input_ids.to(DEVICE), att_mask.to(DEVICE), labels.to(DEVICE)\n", + " with torch.no_grad():\n", + " # model = torch.load(\"best_bert_model.pth\")\n", + " # model.to(DEVICE)\n", + " output = model(input_ids,att_mask)\n", + " output = output.cpu()\n", + " labels = labels.cpu()\n", + " pred_flat = np.argmax(a=output,axis=1).flatten()\n", + " test_accuracy[index] = accuracy_score(labels,pred_flat)\n", + "\n", + " return test_accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.6875, 0.5625, 0.75 , 0.625 , 0.625 , 0.75 , 0.6875, 0.5 ,\n", + " 0.375 , 0.1875, 0.4375, 0.75 , 0.75 , 0.8125, 0.5 , 0.5 ,\n", + " 0.8125, 0.5 , 0.8125, 0.625 , 0.5625, 0.4375, 0.5625, 0.8125,\n", + " 0.6875, 0.8125, 0.625 , 0.6875, 0.5625, 0.75 , 0.8125, 0.8125,\n", + " 0.75 , 0.5 , 0.625 , 0.6875, 0.6875, 0.5 , 0.625 , 0.5625,\n", + " 0.625 , 0.4375, 0.6875, 0.75 , 0.6875, 0.1875, 0.625 , 0.5 ,\n", + " 0.875 , 0.625 , 0.625 , 0.4375, 0.5625, 0.6875, 0.6875, 0.625 ,\n", + " 0.375 , 0.4375, 0.6875, 0.6875, 0.5625, 0.4375, 0.5 , 0.5625,\n", + " 0.6875, 0.5625, 0.4375, 0.8125, 0.75 , 0.75 , 0.625 , 0.6875,\n", + " 0.5625, 0.9375, 0.5625])" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_acc_score = test_loop(mybert,test_loader)\n", + "test_acc_score" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_test_metrics(accuracy):\n", + " \"\"\"\n", + " Plot Test Metrics of Model (Confiuson Matrix, Accuracy)\n", + " \"\"\"\n", + " plt.plot(accuracy)\n", + " plt.hlines(np.mean(accuracy),0,len(accuracy),'red','dotted','Mean Accuracy {:.4f}'.format(np.mean(accuracy)))\n", + " plt.title(\"Accuracy of Test\")\n", + " plt.xlabel(\"Num Batches\")\n", + " plt.ylabel(\"Accurcy 0.0 - 1.0\")\n", + " plt.grid(True)\n", + " plt.legend()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_test_metrics(test_acc_score)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/bert_no_ernie.py b/bert_no_ernie.py index 7114fe7..4ce3ceb 100644 --- a/bert_no_ernie.py +++ b/bert_no_ernie.py @@ -61,8 +61,10 @@ class CustomBert(nn.Module): # self.sm = nn.Softmax(dim=1) def forward(self, input_ids, attention_mask): - seq_out = self.bfsc(input_ids, attention_mask = attention_mask) - return self.classifier(self.dropout(seq_out[0])) + x = self.bfsc(input_ids, attention_mask = attention_mask) + x = self.dropout(x[0]) + x = self.classifier(x) + return x def freeze_bert_params(self): @@ -73,21 +75,22 @@ class CustomBert(nn.Module): for param in self.bfsc.named_parameters(): param[1].requires_grad_(True) -def training_loop(model:CustomBert,criterion:nn.CrossEntropyLoss,optimizer:optim.AdamW,train_loader:DataLoader,freeze_bert:bool): +def training_loop(model:CustomBert,criterion:nn.CrossEntropyLoss,optimizer:optim.AdamW,train_loader:DataLoader,freeze_bert:bool=False): model.train() if freeze_bert: model.freeze_bert_params() total_loss = 0 len_train_loader = len(train_loader) - for index,train_batch in enumerate(train_loader): + for train_batch in train_loader: + # Set Gradient to Zero optimizer.zero_grad() + # Unpack batch values and "push" it to GPU input_ids, att_mask, labels = train_batch.values() - # print(f"{input_ids.shape}, {att_mask.shape}, {labels.shape}") - # print(f"Iteration {index} of {len_train_loader}") input_ids, att_mask, labels = input_ids.to(DEVICE),att_mask.to(DEVICE),labels.to(DEVICE) + # Feed Model with Data outputs = model(input_ids, attention_mask=att_mask) # print(f"{model.bfsc.}") @@ -96,6 +99,7 @@ def training_loop(model:CustomBert,criterion:nn.CrossEntropyLoss,optimizer:optim loss.backward() optimizer.step() total_loss+=loss.item() + print(f"Training Loss is {(total_loss/len(train_loader)):.4f}") return (total_loss/len(train_loader)) @@ -103,109 +107,47 @@ def eval_loop(model:CustomBert,criterion:nn.CrossEntropyLoss,validation_loader:D model.eval() total, correct = 0.0, 0.0 total_loss = 0.0 - best_loss = 10.0 + best_loss = float("Inf") with torch.no_grad(): for val_batch in validation_loader: + input_ids, att_mask ,labels = val_batch.values() input_ids, att_mask, labels = input_ids.to(DEVICE),att_mask.to(DEVICE), labels.to(DEVICE) + outputs = model(input_ids,attention_mask=att_mask) + loss = criterion(outputs,labels) total_loss += loss.item() + predictions = torch.argmax(outputs,1) total += labels.size(0) correct += (predictions == labels).sum().item() + if total_loss/len(validation_loader) < best_loss: best_loss = total_loss/len(validation_loader) - torch.save(model,"best_bert_model") - print(f"Validation Loss: {total_loss/len(validation_loader):.4f} ### Test Accuracy {correct/total*100:.4f}%") + torch.save(model,"best_bert_model.pt") + + print(f"Validation Loss: {total_loss/len(validation_loader):.4f} ### Validation Accuracy {correct/total*100:.4f}%") return total_loss/len(validation_loader) -def test_loop(model:CustomBert, criterion:nn.CrossEntropyLoss, test_loader:DataLoader): +def test_loop(model:CustomBert, test_loader:DataLoader): for batch in test_loader: input_ids, att_mask, labels = batch.values() input_ids, att_mask, labels = input_ids.to(DEVICE), att_mask.to(DEVICE), labels.to(DEVICE) with torch.no_grad(): + model = torch.load("best_bert_model") + model.to(DEVICE) output = model(input_ids,att_mask) output.detach().cpu().numpy() labels.detach().cpu().numpy() pred_flat = np.argmax(output,1).flatten() print(accuracy_score(labels,pred_flat)) -def performance_metrics(true_labels,predictions): - confusion_matrix(true_labels,predictions) - accuracy_score(true_labels,predictions) - f1_score(true_labels,predictions) - pass - - -if __name__ == "__main__": - - # HYPERPARAMETERS - # Set Max Epoch Amount - EPOCH = 10 - # DROPOUT-PROBABILITY - DROPOUT = 0.1 - # BATCHSIZE - BATCH_SIZE = 16 - #LEARNING RATE - LEARNING_RATE = 1e-5 - # RANDOM SEED - RNDM_SEED = 501 - - torch.manual_seed(RNDM_SEED) - np.random.seed(RNDM_SEED) - torch.cuda.seed_all(RNDM_SEED) - - # Initialize Bert Model with dropout probability and Num End Layers - mybert = CustomBert(DROPOUT) - print("Bert Initialized") - mybert.to(DEVICE) - - - # Read Raw Data from csv and save as DataFrame - df = pd.read_csv("./data/hack.csv",encoding="latin1") - print("Raw Data read") - - # Initialize BertTokenizer from Pretrained - tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased",do_lower_case=True) - print("Tokenizer Initialized") - - #Split DataFrame into Train and Test Sets - train,test = train_test_split(df,random_state=501,test_size=.2) - print("Splitted Data in Train and Test Sets") - test,val = train_test_split(test,random_state=501,test_size=.5) - - # val = [] - # Create Custom Datasets for Train and Test - train_data = SimpleHumorDataset(tokenizer,train) - val_data = SimpleHumorDataset(tokenizer,val) - test_data = SimpleHumorDataset(tokenizer,test) - print("Custom Datasets created") - - - # Initialize Dataloader with Train and Test Sets - train_loader = DataLoader(dataset=train_data,batch_size=BATCH_SIZE,shuffle=True) - validation_loader = DataLoader(dataset=val_data,batch_size=BATCH_SIZE,shuffle=True) - test_loader = DataLoader(dataset=test_data,batch_size=BATCH_SIZE,shuffle=False) - print("DataLoaders created") - - # Set criterion to Cross Entropy and define Adam Optimizer with model parameters and learning rate - criterion_cross_entropy = nn.CrossEntropyLoss() - optimizer_adamW = optim.Adam(mybert.parameters(), lr = LEARNING_RATE) - import time - # Set Scheduler for dynamically Learning Rate adjustment - loss_values = np.zeros(EPOCH) - eval_values = np.zeros(EPOCH) - freeze = False - - for epoch in range(EPOCH): - start = time.time() - print(f"For {epoch+1} the Scores are: ") - loss_values[epoch] = training_loop(mybert,optimizer=optimizer_adamW,criterion=criterion_cross_entropy,train_loader=train_loader,freeze_bert=freeze) - eval_values[epoch] = eval_loop(mybert,criterion=criterion_cross_entropy,validation_loader=test_loader) - end = time.time() - print((end-start),"seconds per epoch needed") - # Visualize Training Loss +def plot_metrics_loss_n_acc(train_loss,validation_loss,train_acc,validation_acc): + """ + Method that plots Loss and Accuracy of Training and Validation Data used in given modelinstance + """ + # Visualize Training Loss # plt.plot(loss_values) # plt.plot(eval_values) # plt.hlines(np.mean(loss_values),xmin=0,xmax=EPOCH,colors='red',linestyles="dotted",label="Average Loss") @@ -214,5 +156,111 @@ if __name__ == "__main__": # plt.xlabel("Num Epochs") # plt.ylabel("Total Loss of Epoch") # plt.show() - for epoch in range(EPOCH): - test_loop(mybert,criterion_cross_entropy,validation_loader) \ No newline at end of file + pass + +def plot_test_metrics(accuracy): + """ + Plot Test Metrics of Model (Confiuson Matrix, Accuracy) + """ + plt.plot(accuracy) + plt.hlines(np.mean(accuracy),0,len(accuracy),'red','dotted','Mean Accuracy %d'.format(np.mean(accuracy))) + plt.title("Accuracy of Test") + plt.xlabel("Num Epochs") + plt.ylabel("Accurcy 0.0 - 1.0") + plt.grid(True) + plt.legend() + plt.show() + +# def performance_metrics(true_labels,predictions): +# confusion_matrix(true_labels,predictions) +# accuracy_score(true_labels,predictions) +# f1_score(true_labels,predictions) +# pass + +def create_datasets(tokenizer:AutoTokenizer,dataframe:pd.DataFrame,train_split_ratio:float,val:bool=False)->tuple[SimpleHumorDataset,SimpleHumorDataset,SimpleHumorDataset]|tuple[SimpleHumorDataset,SimpleHumorDataset]: + if train_split_ratio > 1.0: + raise AssertionError("Trainsplit sollte kleiner(-gleich) 1.0 sein") + train,test = train_test_split(dataframe,train_size=train_split_ratio,random_state=501) + if val: + test,validation = train_test_split(test,train_size=.5,random_state=501) + return SimpleHumorDataset(tokenizer,train), SimpleHumorDataset(tokenizer,test), SimpleHumorDataset(tokenizer,validation) + return SimpleHumorDataset(tokenizer,train), SimpleHumorDataset(tokenizer,test) + +def create_dataloaders(datasets:tuple|list,batchsize:int,shufflelist:list): + train_loader = DataLoader(datasets[0],batchsize,shuffle=shufflelist[0]) + test_loader = DataLoader(datasets[1],batchsize,shuffle=shufflelist[1]) + if len(datasets) == 3: + return train_loader, test_loader, DataLoader(datasets[2],batchsize,shuffle=shufflelist[2]) + return train_loader, test_loader + + +# if __name__ == "__main__": + + # # HYPERPARAMETERS + # # Set Max Epoch Amount + # EPOCH = 10 + # # DROPOUT-PROBABILITY + # DROPOUT = 0.1 + # # BATCHSIZE + # BATCH_SIZE = 16 + # #LEARNING RATE + # LEARNING_RATE = 1e-5 + # # RANDOM SEED + # RNDM_SEED = 501 + # # FREEZE Bert Layers + # FREEZE = True + + # torch.manual_seed(RNDM_SEED) + # np.random.seed(RNDM_SEED) + # torch.cuda.manual_seed_all(RNDM_SEED) + + + # Initialize Bert Model with dropout probability and port to DEVICE + # mybert = CustomBert(DROPOUT) + # print("Bert Initialized") + # mybert.to(DEVICE) + + + # Read Raw Data from csv and save as DataFrame + # df = pd.read_csv("./data/hack.csv",encoding="latin1") + # print("Raw Data read") + + + # Initialize BertTokenizer from Pretrained + # tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-uncased",do_lower_case=True) + # print("Tokenizer Initialized") + + + # Split DataFrame into Train and Test Sets + # Create Custom Datasets for Train and Test + # train_data,test_data,validation_data = create_datasets(tokenizer,df,.7,True) + # print("Splitted Data in Train and Test Sets") + # print("Custom Datasets created") + + + # Initialize Dataloader with Train and Test Sets + # train_loader, test_loader, validation_loader = create_dataloaders([train_data,test_data,validation_data],batchsize=BATCH_SIZE,shufflelist=[True,True,False]) + # print("DataLoaders created") + + + # Set criterion to Cross Entropy and define Adam Optimizer with model parameters and learning rate + # criterion_cross_entropy = nn.CrossEntropyLoss() + # optimizer_adamW = optim.Adam(mybert.parameters(), lr = LEARNING_RATE) + # import time + + + # Set Scheduler for dynamically Learning Rate adjustment + loss_values, eval_values = np.zeros(EPOCH), np.zeros(EPOCH) + + # for epoch in range(EPOCH): + # start = time.time() + # print(f"For {epoch+1} the Scores are: ") + # loss_values[epoch] = training_loop(mybert,optimizer=optimizer_adamW,criterion=criterion_cross_entropy,train_loader=train_loader,freeze_bert=FREEZE) + # eval_values[epoch] = eval_loop(mybert,criterion=criterion_cross_entropy,validation_loader=test_loader) + # end = time.time() + # print((end-start),"seconds per epoch needed") + + # plot_metrics_loss_n_acc("x","x","x","x") + + # for epoch in range(EPOCH): + # test_loop(mybert,validation_loader) \ No newline at end of file From dd57bb2d4bea052afbab984b48515466c47dbfcb Mon Sep 17 00:00:00 2001 From: arman Date: Sat, 15 Feb 2025 13:55:06 +0100 Subject: [PATCH 2/4] transformer mit bootstrap agg --- transformer_bootstrap_agg.py | 310 +++++++++++++++++++++++++++++++++++ 1 file changed, 310 insertions(+) create mode 100644 transformer_bootstrap_agg.py diff --git a/transformer_bootstrap_agg.py b/transformer_bootstrap_agg.py new file mode 100644 index 0000000..3d35d1d --- /dev/null +++ b/transformer_bootstrap_agg.py @@ -0,0 +1,310 @@ +import time +import json +import math + +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns + +from nltk.tokenize import word_tokenize + +import torch +import torch.nn as nn +import torch.optim as optim +from torch.utils.data import DataLoader, Subset +from torch.optim.lr_scheduler import ReduceLROnPlateau + +from sklearn.metrics import accuracy_score, precision_recall_curve, f1_score, confusion_matrix, r2_score +from sklearn.model_selection import KFold +# local imports +import ml_evaluation as ml_eval +import ml_helper +import ml_history +import dataset_generator as data_gen +# class imports +import HumorDataset as humor_ds +import EarlyStopping +import BalancedCELoss + + +torch.manual_seed(0) +np.random.seed(0) + + +best_model_filename = 'best_transformer_reg_model.pt' + +device = ml_helper.get_device(verbose=True) + +embedding_matrix, word_index, vocab_size, d_model = data_gen.create_embedding_matrix() + +vocab_size = len(embedding_matrix) +d_model = len(embedding_matrix[0]) +vocab_size, d_model = embedding_matrix.size() +print(f"vocab_size: {vocab_size}, d_model: {d_model}") + + +class PositionalEncoding(nn.Module): + def __init__(self, d_model, vocab_size=5000, dropout=0.1): + super().__init__() + self.dropout = nn.Dropout(p=dropout) + + pe = torch.zeros(vocab_size, d_model) + position = torch.arange(0, vocab_size, dtype=torch.float).unsqueeze(1) + div_term = torch.exp( + torch.arange(0, d_model, 2).float() + * (-math.log(10000.0) / d_model) + ) + pe[:, 0::2] = torch.sin(position * div_term) + pe[:, 1::2] = torch.cos(position * div_term) + pe = pe.unsqueeze(0) + self.register_buffer("pe", pe) + + def forward(self, x): + x = x + self.pe[:, : x.size(1), :] + return self.dropout(x) + + +class TransformerBinaryClassifier(nn.Module): + def __init__( + self, + embeddings, + nhead=8, + dim_feedforward=2048, + num_layers=6, + positional_dropout=0.1, + classifier_dropout=0.1, + activation="relu", + ): + super().__init__() + + vocab_size, d_model = embeddings.size() + assert d_model % nhead == 0, "nheads must divide evenly into d_model" + + self.emb = nn.Embedding.from_pretrained(embeddings, freeze=False) + + self.pos_encoder = PositionalEncoding( + d_model=d_model, + dropout=positional_dropout, + vocab_size=vocab_size, + ) + + encoder_layer = nn.TransformerEncoderLayer( + d_model=d_model, + nhead=nhead, + dim_feedforward=dim_feedforward, + dropout=classifier_dropout, + ) + self.transformer_encoder = nn.TransformerEncoder( + encoder_layer, + num_layers=num_layers, + ) + self.batch_norm = nn.BatchNorm1d(d_model) + self.classifier = nn.Linear(d_model, 1) + self.d_model = d_model + + def forward(self, x): + x = self.emb(x) * math.sqrt(self.d_model) + x = self.pos_encoder(x) + x = self.transformer_encoder(x) + x = x.mean(dim=1) + x = self.classifier(x) + return x + + +def load_preprocess_data(path_data='data/hack.csv'): + df = pd.read_csv(path_data) + df = df.dropna(subset=['humor_rating']) + + df['y'] = df['humor_rating'] + X = df['text'] + y = df['y'] + return X, y + + +X, y = load_preprocess_data() + +ret_dict = data_gen.split_data(X, y) + +params = { + 'equalize_classes_loss_factor': 0.15, + 'batch_size': 32, + 'epochs': 2, + 'lr': 1e-4, + 'clipping_max_norm': 0, + 'early_stopping_patience': 5, + 'lr_scheduler_factor': 0.5, + 'lr_scheduler_patience': 3, + 'nhead': 2, + 'num_layers': 3, + 'hidden_dim': 10, + 'positional_dropout': 0.5, + 'classifier_dropout': 0.5, + 'weight_decay': 1e-2 +} + +max_len = 280 + +train_dataset = humor_ds.TextDataset(ret_dict['train']['X'], ret_dict['train']['y'], word_index, max_len=max_len) +val_dataset = humor_ds.TextDataset(ret_dict['val']['X'], ret_dict['val']['y'], word_index, max_len=max_len) +test_dataset = humor_ds.TextDataset(ret_dict['test']['X'], ret_dict['test']['y'], word_index, max_len=max_len) + +train_loader = DataLoader(train_dataset, batch_size=params['batch_size'], shuffle=True) +val_loader = DataLoader(val_dataset, batch_size=params['batch_size'], shuffle=False) +test_loader = DataLoader(test_dataset, batch_size=params['batch_size'], shuffle=False) + +early_stopping = EarlyStopping.EarlyStopping(patience=params['early_stopping_patience'], verbose=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) + + # Store for plotting + train_losses, val_losses = [], [] + train_r2_scores, val_r2_scores = [], [] + + for epoch in range(epochs): + model.train() + total_loss = 0 + all_preds, all_targets = [], [] + + for inputs, targets in dataloader: + inputs, targets = inputs.to(device), targets.to(device) + optimizer.zero_grad() + outputs = model(inputs).squeeze() + loss = criterion(outputs, targets.float()) + loss.backward() + optimizer.step() + total_loss += loss.item() + + all_preds.extend(outputs.detach().cpu().numpy()) + all_targets.extend(targets.detach().cpu().numpy()) + + # Calculate R2 + r2 = r2_score(all_targets, all_preds) + train_losses.append(total_loss / len(dataloader)) + train_r2_scores.append(r2) + + # Validation phase + model.eval() + val_loss = 0 + val_preds, val_targets = [], [] + + with torch.no_grad(): + for inputs, targets in val_loader: + inputs, targets = inputs.to(device), targets.to(device) + outputs = model(inputs).squeeze() + loss = criterion(outputs, targets.float()) + val_loss += loss.item() + + val_preds.extend(outputs.cpu().numpy()) + val_targets.extend(targets.cpu().numpy()) + + # Calculate Validation R2 + val_r2 = r2_score(val_targets, val_preds) + val_losses.append(val_loss / len(val_loader)) + val_r2_scores.append(val_r2) + + print(f"Epoch {epoch + 1}/{epochs}, Loss: {total_loss / len(dataloader):.4f}, R^2 (Train): {r2:.4f}, Val R^2: {val_r2:.4f}") + + return train_losses, val_losses, train_r2_scores, val_r2_scores + + +def bootstrap_aggregation(ModelClass, train_dataset, num_models=5, epochs=10, batch_size=32, learning_rate=0.001): + models = [] + all_train_losses, all_val_losses = [], [] + all_train_r2_scores, all_val_r2_scores = [], [] + + subset_size = len(train_dataset) // num_models + + for i in range(num_models): + print(f"Training Model {i + 1}/{num_models}...") + 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) + + model = ModelClass() + criterion = nn.MSELoss() + optimizer = optim.Adam(model.parameters(), lr=learning_rate) + + train_losses, val_losses, train_r2_scores, val_r2_scores = train_model(model, subset, criterion, optimizer, epochs, batch_size) + + models.append(model) + all_train_losses.append(train_losses) + all_val_losses.append(val_losses) + all_train_r2_scores.append(train_r2_scores) + all_val_r2_scores.append(val_r2_scores) + + return models, all_train_losses, all_val_losses, all_train_r2_scores, all_val_r2_scores + + +# Ensemble Prediction +def ensemble_predict(models, test_dataset): + dataloader = DataLoader(test_dataset, batch_size=32, shuffle=False) + all_predictions = [] + + with torch.no_grad(): + for inputs, _ in dataloader: + inputs = inputs.to(device) + predictions = torch.stack([model(inputs).squeeze() for model in models]) + avg_predictions = predictions.mean(dim=0) + all_predictions.extend(avg_predictions.cpu().numpy()) + + return np.array(all_predictions) + + +# Bootstrap Aggregating +num_models = 2 +ensemble_models, all_train_losses, all_val_losses, all_train_r2_scores, all_val_r2_scores = bootstrap_aggregation( + lambda: TransformerBinaryClassifier( + embeddings=embedding_matrix, + nhead=params['nhead'], + num_layers=params['num_layers'], + dim_feedforward=params['hidden_dim'], + positional_dropout=params['positional_dropout'], + classifier_dropout=params['classifier_dropout'] + ).to(device), + train_dataset, + num_models=num_models, + epochs=params['epochs'], + batch_size=params['batch_size'], + learning_rate=params['lr'] +) + +# Ensemble Prediction on Testset +ensemble_predictions = ensemble_predict(ensemble_models, test_dataset) + +# Plotting +fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6)) + +# Plot Train and Validation Losses +for i in range(num_models): + ax1.plot(range(1, params['epochs'] + 1), all_train_losses[i], label=f"Train Model {i+1}") + ax1.plot(range(1, params['epochs'] + 1), all_val_losses[i], label=f"Val Model {i+1}") + +ax1.set_title('Train and Validation Loss') +ax1.set_xlabel('Epochs') +ax1.set_ylabel('Loss') +ax1.legend() + +# Plot Train and Validation R² +for i in range(num_models): + ax2.plot(range(1, params['epochs'] + 1), all_train_r2_scores[i], label=f"Train Model {i+1}") + ax2.plot(range(1, params['epochs'] + 1), all_val_r2_scores[i], label=f"Val Model {i+1}") + +ax2.set_title('Train and Validation R²') +ax2.set_xlabel('Epochs') +ax2.set_ylabel('R²') +ax2.legend() + +plt.tight_layout() +plt.show() + +# Evaluation +mse = mean_squared_error(test_dataset.labels.to_numpy(), ensemble_predictions) +mae = mean_absolute_error(test_dataset.labels.to_numpy(), ensemble_predictions) +r2 = r2_score(test_dataset.labels.to_numpy(), ensemble_predictions) + +print(f"Ensemble MSE: {mse:.4f}, MAE: {mae:.4f}, R²: {r2:.4f}") From 75be160902e0faf725585a92f316502f06df7352 Mon Sep 17 00:00:00 2001 From: Michelle Goeppinger Date: Sat, 15 Feb 2025 14:01:42 +0100 Subject: [PATCH 3/4] clean up --- CNN_CLASS.py | 227 ++++++++ TEST_CNN_2.py => CNN_REG.py | 41 -- cnn.py | 203 ------- cnn_class.ipynb | 841 +++++++++++++++++--------- cnn_reg.ipynb | 1101 +++++++++++++++++++++-------------- cnn_reg_test.ipynb | 485 --------------- test_cnn.py | 186 ------ 7 files changed, 1471 insertions(+), 1613 deletions(-) create mode 100644 CNN_CLASS.py rename TEST_CNN_2.py => CNN_REG.py (86%) delete mode 100644 cnn.py delete mode 100644 cnn_reg_test.ipynb delete mode 100644 test_cnn.py diff --git a/CNN_CLASS.py b/CNN_CLASS.py new file mode 100644 index 0000000..699a059 --- /dev/null +++ b/CNN_CLASS.py @@ -0,0 +1,227 @@ +import torch +import torch.nn as nn +import torch.optim as optim +from torch.utils.data import DataLoader +from sklearn.metrics import accuracy_score +from tqdm import tqdm +from dataset_generator import create_embedding_matrix, split_data, load_preprocess_data +from HumorDataset import TextDataset +from BalancedCELoss import BalancedCELoss +import matplotlib.pyplot as plt +import numpy as np + +# Hyperparameter und Konfigurationen +params = { + "embedding_dim": 100, + "filter_sizes": [2, 3, 4, 5], + "num_filters": 150, + "batch_size": 32, + "learning_rate": 0.001, + "epochs": 25, + "glove_path": 'data/glove.6B.100d.txt', + "max_len": 280, + "test_size": 0.1, + "val_size": 0.1, + "patience": 5, + "data_path": 'data/hack.csv', + "dropout": 0.6, + "weight_decay": 5e-4, + "alpha": 0.1 # Alpha für die Balance in der Loss-Funktion +} + +# CNN-Modell für binäre Klassifikation +class EnhancedCNNBinaryClassifier(nn.Module): + def __init__(self, vocab_size, embedding_dim, filter_sizes, num_filters, embedding_matrix, dropout): + super(EnhancedCNNBinaryClassifier, self).__init__() + self.embedding = nn.Embedding.from_pretrained(embedding_matrix, freeze=False) + self.convs = nn.ModuleList([ + nn.Sequential( + nn.Conv2d(1, num_filters, (fs, embedding_dim)), + nn.BatchNorm2d(num_filters), + nn.ReLU(), + nn.MaxPool2d((params["max_len"] - fs + 1, 1)), + nn.Dropout(dropout) + ) + for fs in filter_sizes + ]) + self.fc1 = nn.Linear(len(filter_sizes) * num_filters, 128) + self.fc2 = nn.Linear(128, 2) # 2 Klassen, daher 2 Outputs für CrossEntropyLoss + self.dropout = nn.Dropout(dropout) + + def forward(self, x): + x = self.embedding(x).unsqueeze(1) + conv_outputs = [conv(x).squeeze(3).squeeze(2) for conv in self.convs] + x = torch.cat(conv_outputs, 1) + x = torch.relu(self.fc1(x)) + x = self.dropout(x) + return self.fc2(x) # 2 Outputs, CrossEntropyLoss übernimmt die Softmax + +# Visualisierungsfunktionen +def visualize_predictions(true_values, predicted_values): + plt.figure(figsize=(10, 6)) + + # Unterschied zwischen vorhergesagten und wahren Werten + true_values = np.array(true_values) + predicted_values = np.array(predicted_values) + + correct_indices = true_values == predicted_values + incorrect_indices = ~correct_indices + + # Scatterplot + plt.scatter( + np.arange(len(true_values))[correct_indices], + true_values[correct_indices], + color='green', + label='Richtig vorhergesagt' + ) + plt.scatter( + np.arange(len(true_values))[incorrect_indices], + true_values[incorrect_indices], + color='red', + label='Falsch vorhergesagt' + ) + + plt.axhline(0.5, linestyle='--', color='blue', label='Schwelle (0.5)') + plt.ylim(-0.5, 1.5) + plt.yticks([0, 1], labels=['Klasse 0', 'Klasse 1']) + plt.xlabel('Datenindex') + plt.ylabel('Klassifikation') + plt.title('Richtige vs. Falsche Vorhersagen') + plt.legend() + plt.grid(True, linestyle='--', alpha=0.6) + plt.tight_layout() + plt.show() + +def visualize_distribution(true_values, predicted_values): + plt.figure(figsize=(10, 6)) + + # Häufigkeiten der Klassen berechnen + true_counts = np.bincount(true_values, minlength=2) + predicted_counts = np.bincount(predicted_values, minlength=2) + + # Barplot erstellen + labels = ['Klasse 0', 'Klasse 1'] + x = np.arange(len(labels)) + + plt.bar(x - 0.2, true_counts, width=0.4, color='skyblue', label='Wahre Werte', edgecolor='black') + plt.bar(x + 0.2, predicted_counts, width=0.4, color='salmon', label='Vorhergesagte Werte', edgecolor='black') + + plt.title('Verteilung der wahren Werte und Vorhersagen') + plt.xticks(x, labels) + plt.ylabel('Häufigkeit') + plt.xlabel('Klassen') + plt.legend() + plt.grid(axis='y', linestyle='--', alpha=0.7) + plt.tight_layout() + plt.show() + +# Gerät initialisieren +device = torch.device("cuda" if torch.cuda.is_available() else "cpu") +print(f"Using device: {device}") + +# Daten laden +embedding_matrix, word_index, vocab_size, d_model = create_embedding_matrix( + gloVe_path=params["glove_path"], emb_len=params["embedding_dim"] +) +X, y = load_preprocess_data(path_data=params["data_path"]) + +# Daten splitten +data_split = split_data(X, y, test_size=params["test_size"], val_size=params["val_size"]) +train_dataset = TextDataset(data_split['train']['X'], data_split['train']['y'], word_index, max_len=params["max_len"]) +val_dataset = TextDataset(data_split['val']['X'], data_split['val']['y'], word_index, max_len=params["max_len"]) +test_dataset = TextDataset(data_split['test']['X'], data_split['test']['y'], word_index, max_len=params["max_len"]) + +train_loader = DataLoader(train_dataset, batch_size=params["batch_size"], shuffle=True) +val_loader = DataLoader(val_dataset, batch_size=params["batch_size"], shuffle=False) +test_loader = DataLoader(test_dataset, batch_size=params["batch_size"], shuffle=False) + +# Modell initialisieren +model = EnhancedCNNBinaryClassifier( + vocab_size=vocab_size, + embedding_dim=params["embedding_dim"], + filter_sizes=params["filter_sizes"], + num_filters=params["num_filters"], + embedding_matrix=embedding_matrix, + dropout=params["dropout"] +) +model = model.to(device) + +# BalancedCELoss verwenden +criterion = BalancedCELoss(alpha=params["alpha"]) +optimizer = optim.Adam(model.parameters(), lr=params["learning_rate"], weight_decay=params["weight_decay"]) + +# Training +history = { + "train_loss": [], + "val_loss": [], + "train_acc": [], + "val_acc": [], +} + +for epoch in range(params["epochs"]): + model.train() + train_loss, correct, total = 0.0, 0, 0 + + with tqdm(train_loader, desc=f"Epoch {epoch + 1}/{params['epochs']}") as pbar: + for X_batch, y_batch in pbar: + X_batch, y_batch = X_batch.to(device), y_batch.to(device) + optimizer.zero_grad() + outputs = model(X_batch) + loss = criterion(outputs, y_batch) + loss.backward() + optimizer.step() + + train_loss += loss.item() + predicted = torch.argmax(outputs, dim=1) + correct += (predicted == y_batch).sum().item() + total += y_batch.size(0) + + pbar.set_postfix({"Train Loss": loss.item()}) + + train_acc = correct / total + history["train_loss"].append(train_loss / len(train_loader)) + history["train_acc"].append(train_acc) + + # Validation + model.eval() + val_loss, correct, total = 0.0, 0, 0 + with torch.no_grad(): + for X_batch, y_batch in val_loader: + X_batch, y_batch = X_batch.to(device), y_batch.to(device) + outputs = model(X_batch) + loss = criterion(outputs, y_batch) + val_loss += loss.item() + predicted = torch.argmax(outputs, dim=1) + correct += (predicted == y_batch).sum().item() + total += y_batch.size(0) + + val_acc = correct / total + history["val_loss"].append(val_loss / len(val_loader)) + history["val_acc"].append(val_acc) + + print(f"\nEpoch {epoch + 1}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}") + print(f"Train Accuracy: {train_acc:.4f}, Val Accuracy: {val_acc:.4f}") + +# Testen und Visualisieren +model.eval() +test_correct, test_total = 0, 0 +true_labels, predicted_labels = [], [] + +with torch.no_grad(): + for X_batch, y_batch in test_loader: + X_batch, y_batch = X_batch.to(device), y_batch.to(device) + outputs = model(X_batch) + predicted = torch.argmax(outputs, dim=1) + true_labels.extend(y_batch.cpu().numpy()) + predicted_labels.extend(predicted.cpu().numpy()) + test_correct += (predicted == y_batch).sum().item() + test_total += y_batch.size(0) + +test_accuracy = test_correct / test_total +print(f"Test Accuracy: {test_accuracy:.4f}") + +# Visualisierung der Vorhersagen (Scatterplot) +visualize_predictions(true_labels, predicted_labels) + +# Visualisierung der Verteilung (Barplot) +visualize_distribution(true_labels, predicted_labels) diff --git a/TEST_CNN_2.py b/CNN_REG.py similarity index 86% rename from TEST_CNN_2.py rename to CNN_REG.py index ea1a7fb..7e5485c 100644 --- a/TEST_CNN_2.py +++ b/CNN_REG.py @@ -302,47 +302,6 @@ test_mae = mean_absolute_error(test_labels, test_preds) test_r2 = r2_score(test_labels, test_preds) print(f"Test RMSE: {test_rmse:.4f}, Test MAE: {test_mae:.4f}, Test R²: {test_r2:.4f}") -# Funktion zur Visualisierung der richtigen und falschen Vorhersagen -def visualize_predictions(true_values, predicted_values): - plt.figure(figsize=(10, 6)) - - # Unterschied zwischen vorhergesagten und wahren Werten - correct_indices = np.isclose(true_values, predicted_values, atol=0.3) # Als korrekt angenommen, wenn Differenz <= 0.3 - - # Plot - plt.scatter(true_values[correct_indices], predicted_values[correct_indices], color='green', label='Richtig vorhergesagt') - plt.scatter(true_values[~correct_indices], predicted_values[~correct_indices], color='red', label='Falsch vorhergesagt') - plt.plot([min(true_values), max(true_values)], [min(true_values), max(true_values)], color='blue', linestyle='--', label='Ideal-Linie') - - plt.xlabel('Wahre Werte') - plt.ylabel('Vorhergesagte Werte') - plt.title('Richtige vs Falsche Vorhersagen') - plt.legend() - plt.grid(True) - plt.show() - -# Test Evaluation -model.eval() -test_preds, test_labels = [], [] -with torch.no_grad(): - for X_batch, y_batch in test_loader: - X_batch, y_batch = X_batch.to(device), y_batch.to(device).float() - predictions = model(X_batch).float() - test_preds.extend(predictions.cpu().detach().numpy()) - test_labels.extend(y_batch.cpu().detach().numpy()) - -# Konvertierung zu NumPy-Arrays -true_values = np.array(test_labels) -predicted_values = np.array(test_preds) - -# Visualisierung der Ergebnisse -visualize_predictions(true_values, predicted_values) - -# RMSE, MAE und R²-Score für das Test-Set -test_rmse = np.sqrt(mean_squared_error(test_labels, test_preds)) -test_mae = mean_absolute_error(test_labels, test_preds) -test_r2 = r2_score(test_labels, test_preds) -print(f"Test RMSE: {test_rmse:.4f}, Test MAE: {test_mae:.4f}, Test R²: {test_r2:.4f}") # plot distribution of predicted values and true values diff --git a/cnn.py b/cnn.py deleted file mode 100644 index 53cde1d..0000000 --- a/cnn.py +++ /dev/null @@ -1,203 +0,0 @@ -import torch -import torch.nn as nn -import torch.optim as optim -import pandas as pd -import numpy as np -from sklearn.model_selection import train_test_split -from nltk.tokenize import word_tokenize -from torch.utils.data import DataLoader, Dataset -from sklearn.metrics import accuracy_score -import gensim -import nltk -import time -import matplotlib.pyplot as plt - -# NLTK Downloads -nltk.download('punkt') # Entferne punkt_tab, da es nicht existiert - -# Check if GPU is available -DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu') -print('Using device:', DEVICE) - -# Maximum sequence length -MAX_LEN = 100 - -# Data helpers -def get_embedding(model, word): - if word in model.wv: - return model.wv.key_to_index[word] - else: - return unk_index - -def encode_tokens(tokens): - return [get_embedding(model_embedding, token) for token in tokens] - -def pad_sequences(sequences, MAX_LEN): - return np.array([np.pad(seq, (0, MAX_LEN - len(seq)), mode='constant', constant_values=unk_index) - if len(seq) < MAX_LEN else seq[:MAX_LEN] for seq in sequences]) - -# Dataset class -class HumorDataset(Dataset): - def __init__(self, encodings, labels): - self.encodings = encodings - self.labels = labels - - def __getitem__(self, idx): - item = {'input_ids': torch.tensor(self.encodings[idx], dtype=torch.long)} - item['labels'] = torch.tensor(self.labels[idx], dtype=torch.float) - return item - - def __len__(self): - return len(self.labels) - -# CNN Model -class CNNBinaryClassifier(nn.Module): - def __init__(self, vocab_size, embed_dim, num_filters, kernel_sizes, hidden_dim, dropout=0.1): - super(CNNBinaryClassifier, self).__init__() - self.embedding = nn.Embedding(vocab_size, embed_dim) - self.conv_layers = nn.ModuleList([ - nn.Conv1d(in_channels=embed_dim, out_channels=num_filters, kernel_size=k) - for k in kernel_sizes - ]) - self.fc = nn.Linear(num_filters * len(kernel_sizes), hidden_dim) - self.out = nn.Linear(hidden_dim, 1) - self.relu = nn.ReLU() - self.dropout = nn.Dropout(dropout) - self.sigmoid = nn.Sigmoid() - - def forward(self, input_ids): - embedded = self.embedding(input_ids).permute(0, 2, 1) - conv_outs = [self.relu(conv(embedded)) for conv in self.conv_layers] - pooled_outs = [torch.max(out, dim=2)[0] for out in conv_outs] - concatenated = torch.cat(pooled_outs, dim=1) - fc_out = self.relu(self.fc(self.dropout(concatenated))) - logits = self.out(fc_out) - return self.sigmoid(logits) - -# Main script -if __name__ == "__main__": - # Load and process data - df = pd.read_csv('/content/hack.csv') - print(f"Loaded dataset: {df.shape}") - - X = df['text'].fillna("unknown").astype(str) - y = df['is_humor'] - - # Train-test split - X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) - - # Tokenization with error handling - train_tokens = [] - test_tokens = [] - - for text in X_train: - try: - train_tokens.append(word_tokenize(text.lower())) - except Exception as e: - print(f"Error tokenizing: {text}. Error: {e}") - train_tokens.append(["unknown"]) - - for text in X_test: - try: - test_tokens.append(word_tokenize(text.lower())) - except Exception as e: - print(f"Error tokenizing: {text}. Error: {e}") - test_tokens.append(["unknown"]) - - print("Sample tokenization (Train):", train_tokens[:2]) - print("Sample tokenization (Test):", test_tokens[:2]) - - # Train Word2Vec model - model_embedding = gensim.models.Word2Vec(train_tokens, vector_size=100, window=5, min_count=1, workers=4) - - # Add unknown token - model_embedding.wv.add_vector('', np.zeros(model_embedding.vector_size)) - unk_index = model_embedding.wv.key_to_index[''] - - # Encode tokens - train_encodings = [encode_tokens(tokens) for tokens in train_tokens] - test_encodings = [encode_tokens(tokens) for tokens in test_tokens] - - # Pad sequences with validation - train_encodings = pad_sequences(train_encodings, MAX_LEN) - test_encodings = pad_sequences(test_encodings, MAX_LEN) - - if len(train_encodings) == 0 or len(test_encodings) == 0: - raise ValueError("Tokenization or padding failed. Please check your input data.") - - # Create datasets - train_dataset = HumorDataset(train_encodings, y_train.reset_index(drop=True)) - test_dataset = HumorDataset(test_encodings, y_test.reset_index(drop=True)) - - # Model parameters - vocab_size = len(model_embedding.wv.key_to_index) - embed_dim = model_embedding.vector_size - num_filters = 200 - kernel_sizes = [3, 4, 5] - hidden_dim = 128 - dropout = 0.5 - - model = CNNBinaryClassifier(vocab_size, embed_dim, num_filters, kernel_sizes, hidden_dim, dropout) - - # Training parameters - epochs = 10 - batch_size = 8 - learning_rate = 2e-5 - - # Optimizer and loss function - optimizer = optim.Adam(model.parameters(), lr=learning_rate) - criterion = nn.BCELoss() - - # Data loaders - train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True) - test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False) - - # Move model to device - model.to(DEVICE) - - print("Starting training...") - train_losses = [] - - # Training loop - for epoch in range(epochs): - epoch_loss = 0 - model.train() - for batch in train_loader: - optimizer.zero_grad() - input_ids = batch['input_ids'].to(DEVICE) - labels = batch['labels'].unsqueeze(1).to(DEVICE) - outputs = model(input_ids) - loss = criterion(outputs, labels) - loss.backward() - optimizer.step() - epoch_loss += loss.item() - - train_loss = epoch_loss / len(train_loader) - train_losses.append(train_loss) - print(f"Epoch {epoch + 1}/{epochs}, Train Loss: {train_loss:.4f}") - - # Visualize training loss - plt.figure(figsize=(10, 6)) - plt.plot(range(1, epochs + 1), train_losses, marker='o', linestyle='-', label='Train Loss') - plt.xlabel('Epoch') - plt.ylabel('Loss') - plt.title('Training Loss Over Epochs') - plt.legend() - plt.grid(True) - plt.show() - - print("Starting evaluation...") - # Evaluation - model.eval() - predictions, true_labels = [], [] - with torch.no_grad(): - for batch in test_loader: - input_ids = batch['input_ids'].to(DEVICE) - labels = batch['labels'].unsqueeze(1).to(DEVICE) - outputs = model(input_ids) - preds = (outputs > 0.5).float() - predictions.extend(preds.cpu().numpy()) - true_labels.extend(labels.cpu().numpy()) - - accuracy = accuracy_score(true_labels, predictions) - print(f"Final Accuracy: {accuracy:.4f}") diff --git a/cnn_class.ipynb b/cnn_class.ipynb index 7b5f2e0..5b4e832 100644 --- a/cnn_class.ipynb +++ b/cnn_class.ipynb @@ -16,22 +16,25 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 76, "metadata": {}, "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", - "import torch.nn.functional as F\n", "import torch.optim as optim\n", "from torch.utils.data import DataLoader\n", - "from torch.optim.lr_scheduler import ReduceLROnPlateau\n", - "from sklearn.metrics import accuracy_score, f1_score, confusion_matrix\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", + "from sklearn.metrics import accuracy_score\n", + "\n", "from tqdm import tqdm\n", - "import pandas as pd" + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "#lokal imports\n", + "from dataset_generator import create_embedding_matrix, split_data, load_preprocess_data\n", + "from HumorDataset import TextDataset\n", + "from BalancedCELoss import BalancedCELoss\n", + "import ml_helper" ] }, { @@ -43,40 +46,17 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 77, "metadata": {}, "outputs": [], "source": [ - "# Definiere die Dataset-Klasse\n", - "class HumorDataset(torch.utils.data.Dataset):\n", - " def __init__(self, data):\n", - " self.data = data\n", + "torch.manual_seed(0)\n", + "np.random.seed(0)\n", "\n", - " def __getitem__(self, index):\n", - " input_ids = torch.tensor(np.array(self.data[index][\"input_ids\"]), dtype=torch.float32) # (seq_len, embedding_dim)\n", - " label = torch.tensor([self.data[index][\"labels\"]], dtype=torch.float32) # (1,)\n", - " return input_ids, label\n", "\n", - " def __len__(self):\n", - " return len(self.data)\n", - "\n", - "# Lade die vorbereiteten Daten\n", - "train_data = torch.load(data_path + '/train.pt', weights_only=False)\n", - "val_data = torch.load(data_path + '/val.pt', weights_only=False)\n", - "test_data = torch.load(data_path + '/test.pt', weights_only=False)\n", - "\n", - "train_dataset = HumorDataset(train_data)\n", - "val_dataset = HumorDataset(val_data)\n", - "test_dataset = HumorDataset(test_data)\n", - "\n", - "# DataLoader erstellen\n", - "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n", - "val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False)\n", - "test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False)\n", - "\n", - "# Ableitung der Dimensionen aus den Daten\n", - "sample_input, _ = train_dataset[0] # Extrahiere input_ids\n", - "seq_len, embedding_dim = sample_input.shape\n" + "best_model_filename = 'best_cnn_class_model.pt'\n", + "#device = ml_helper.get_device(verbose=True)\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" ] }, { @@ -89,411 +69,649 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 78, "metadata": {}, "outputs": [], "source": [ - "# Single-Kernel CNN-Modell\n", - "class SingleKernelCNN(nn.Module):\n", - " def __init__(self, embedding_dim, num_classes=1, kernel_size=5, num_filters=100, dropout=0.5, use_highway=True):\n", - " super(SingleKernelCNN, self).__init__()\n", - " # Convolutional Layer mit Kernel \n", - " self.conv = nn.Conv2d(1, num_filters, (kernel_size, embedding_dim))\n", - " \n", - " # Optional Highway Layer\n", - " self.use_highway = use_highway\n", - " if self.use_highway:\n", - " self.highway = nn.Linear(num_filters, num_filters)\n", - " \n", - " # Fully Connected Layer\n", - " self.fc = nn.Linear(num_filters, num_classes)\n", - " \n", - " # Dropout zur Regularisierung\n", + "# Hyperparameter und Konfigurationen\n", + "params = {\n", + " \"embedding_dim\": 100,\n", + " \"filter_sizes\": [2, 3, 4, 5],\n", + " \"num_filters\": 150,\n", + " \"batch_size\": 32,\n", + " \"learning_rate\": 0.001,\n", + " \"epochs\": 25,\n", + " \"glove_path\": 'data/glove.6B.100d.txt',\n", + " \"max_len\": 280,\n", + " \"test_size\": 0.1,\n", + " \"val_size\": 0.1,\n", + " \"patience\": 5,\n", + " \"data_path\": 'data/hack.csv',\n", + " \"dropout\": 0.6,\n", + " \"weight_decay\": 5e-4,\n", + " \"alpha\": 0.1, # Alpha für die Balance in der Loss-Funktion\n", + " # patience for early stopping\n", + " 'early_stopping_patience': 5 # 5 (3 to 10)\n", + "\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [], + "source": [ + "class CNNBinaryClassifier(nn.Module):\n", + " def __init__(self, vocab_size, embedding_dim, filter_sizes, num_filters, embedding_matrix, dropout):\n", + " super(CNNBinaryClassifier, self).__init__()\n", + " self.embedding = nn.Embedding.from_pretrained(embedding_matrix, freeze=False)\n", + " self.convs = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Conv2d(1, num_filters, (fs, embedding_dim)),\n", + " nn.BatchNorm2d(num_filters),\n", + " nn.ReLU(),\n", + " nn.MaxPool2d((params[\"max_len\"] - fs + 1, 1)),\n", + " nn.Dropout(dropout)\n", + " )\n", + " for fs in filter_sizes\n", + " ])\n", + " self.fc1 = nn.Linear(len(filter_sizes) * num_filters, 128)\n", + " self.fc2 = nn.Linear(128, 2) # 2 Klassen, daher 2 Outputs für CrossEntropyLoss\n", " self.dropout = nn.Dropout(dropout)\n", "\n", " def forward(self, x):\n", - " # Eingabe x-Form: (batch_size, seq_len, embedding_dim)\n", - " x = x.unsqueeze(1) # Füge Kanaldimension hinzu: (batch_size, 1, seq_len, embedding_dim)\n", - " \n", - " # Convolution + ReLU\n", - " x = F.relu(self.conv(x).squeeze(3)) # Entferne die letzte Dimension nach der Convolution\n", - " \n", - " # Max Pooling über die Sequenzlänge\n", - " x = F.max_pool1d(x, x.size(2)).squeeze(2) # Reduziere auf (batch_size, num_filters)\n", - " \n", - " # Optionaler Highway-Mechanismus\n", - " if self.use_highway:\n", - " highway_gate = torch.sigmoid(self.highway(x))\n", - " x = highway_gate * F.relu(self.highway(x)) + (1 - highway_gate) * x\n", - " \n", - " # Dropout zur Regularisierung\n", + " x = self.embedding(x).unsqueeze(1)\n", + " conv_outputs = [conv(x).squeeze(3).squeeze(2) for conv in self.convs]\n", + " x = torch.cat(conv_outputs, 1)\n", + " x = torch.relu(self.fc1(x))\n", " x = self.dropout(x)\n", - " \n", - " # Fully Connected Layer für die Ausgabe\n", - " logits = self.fc(x)\n", - " return torch.sigmoid(logits) # Binäre Klassifikation\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "\n", - "### Training des Modells\n" + " return self.fc2(x) # 2 Outputs, CrossEntropyLoss übernimmt die Softmax" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "400002\n", + "vocab_size: 400002, d_model: 100\n" + ] + } + ], + "source": [ + "# Daten laden\n", + "embedding_matrix, word_index, vocab_size, d_model = create_embedding_matrix(\n", + " gloVe_path=params[\"glove_path\"], emb_len=params[\"embedding_dim\"]\n", + ")\n", + "X, y = load_preprocess_data(path_data=params[\"data_path\"])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train 3945 3945\n", + "test 494 494\n", + "val 493 493\n" + ] + } + ], + "source": [ + "\n", + "# Daten splitten\n", + "data_split = split_data(X, y, test_size=params[\"test_size\"], val_size=params[\"val_size\"])\n", + "train_dataset = TextDataset(data_split['train']['X'], data_split['train']['y'], word_index, max_len=params[\"max_len\"])\n", + "val_dataset = TextDataset(data_split['val']['X'], data_split['val']['y'], word_index, max_len=params[\"max_len\"])\n", + "test_dataset = TextDataset(data_split['test']['X'], data_split['test']['y'], word_index, max_len=params[\"max_len\"])\n", + "\n", + "train_loader = DataLoader(train_dataset, batch_size=params[\"batch_size\"], shuffle=True)\n", + "val_loader = DataLoader(val_dataset, batch_size=params[\"batch_size\"], shuffle=False)\n", + "test_loader = DataLoader(test_dataset, batch_size=params[\"batch_size\"], shuffle=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "import EarlyStopping as EarlyStopping\n", + "# Modell initialisieren\n", + "model = CNNBinaryClassifier(\n", + " vocab_size=vocab_size,\n", + " embedding_dim=params[\"embedding_dim\"],\n", + " filter_sizes=params[\"filter_sizes\"],\n", + " num_filters=params[\"num_filters\"],\n", + " embedding_matrix=embedding_matrix,\n", + " dropout=params[\"dropout\"]\n", + ")\n", + "model = model.to(device)\n", + "\n", + "# BalancedCELoss verwenden\n", + "criterion = BalancedCELoss(alpha=params[\"alpha\"])\n", + "optimizer = optim.Adam(model.parameters(), lr=params[\"learning_rate\"], weight_decay=params[\"weight_decay\"])\n", + "early_stopping = EarlyStopping.EarlyStopping(patience=params['early_stopping_patience'], verbose=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 83, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/michellegoppinger/.pyenv/versions/3.12.3/lib/python3.12/site-packages/torch/optim/lr_scheduler.py:62: UserWarning: The verbose parameter is deprecated. Please use get_last_lr() to access the learning rate.\n", - " warnings.warn(\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 1/30: 100%|██████████| 124/124 [00:23<00:00, 5.22batch/s, loss=0.705]\n" + "Epoch 1/25: 100%|██████████| 124/124 [00:38<00:00, 3.26it/s, Train Loss=0.734]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 1, Train Loss: 0.6845, Val Loss: 0.6565\n" + "\n", + "Epoch 1, Train Loss: 105.9015, Val Loss: 12.5712\n", + "Train Accuracy: 0.4958, Val Accuracy: 0.5314\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Epoch 2/30: 100%|██████████| 124/124 [00:23<00:00, 5.30batch/s, loss=0.728]\n" + "Epoch 2/25: 100%|██████████| 124/124 [00:36<00:00, 3.39it/s, Train Loss=0.79] \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 2, Train Loss: 0.6486, Val Loss: 0.6301\n" + "\n", + "Epoch 2, Train Loss: 91.0446, Val Loss: 12.5252\n", + "Train Accuracy: 0.5141, Val Accuracy: 0.5274\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Epoch 3/30: 100%|██████████| 124/124 [00:23<00:00, 5.24batch/s, loss=0.513]\n" + "Epoch 3/25: 100%|██████████| 124/124 [00:36<00:00, 3.39it/s, Train Loss=0.826]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 3, Train Loss: 0.6193, Val Loss: 0.6441\n" + "\n", + "Epoch 3, Train Loss: 93.3248, Val Loss: 12.5840\n", + "Train Accuracy: 0.5039, Val Accuracy: 0.5254\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Epoch 4/30: 100%|██████████| 124/124 [00:23<00:00, 5.29batch/s, loss=0.53] \n" + "Epoch 4/25: 100%|██████████| 124/124 [00:36<00:00, 3.40it/s, Train Loss=0.7] \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 4, Train Loss: 0.5953, Val Loss: 0.6143\n" + "\n", + "Epoch 4, Train Loss: 92.2199, Val Loss: 12.5006\n", + "Train Accuracy: 0.4984, Val Accuracy: 0.5517\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Epoch 5/30: 100%|██████████| 124/124 [00:24<00:00, 5.11batch/s, loss=0.391]\n" + "Epoch 5/25: 100%|██████████| 124/124 [00:37<00:00, 3.29it/s, Train Loss=0.768]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 5, Train Loss: 0.5613, Val Loss: 0.6189\n" + "\n", + "Epoch 5, Train Loss: 91.2856, Val Loss: 11.9061\n", + "Train Accuracy: 0.5290, Val Accuracy: 0.5862\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Epoch 6/30: 100%|██████████| 124/124 [00:23<00:00, 5.25batch/s, loss=0.435]\n" + "Epoch 6/25: 100%|██████████| 124/124 [00:40<00:00, 3.09it/s, Train Loss=0.694]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 6, Train Loss: 0.5350, Val Loss: 0.6127\n" + "\n", + "Epoch 6, Train Loss: 90.5596, Val Loss: 11.3011\n", + "Train Accuracy: 0.5430, Val Accuracy: 0.6126\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Epoch 7/30: 100%|██████████| 124/124 [00:23<00:00, 5.29batch/s, loss=0.595]\n" + "Epoch 7/25: 100%|██████████| 124/124 [00:39<00:00, 3.18it/s, Train Loss=0.771]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 7, Train Loss: 0.5055, Val Loss: 0.6162\n" + "\n", + "Epoch 7, Train Loss: 89.5808, Val Loss: 11.5313\n", + "Train Accuracy: 0.5582, Val Accuracy: 0.6207\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Epoch 8/30: 100%|██████████| 124/124 [00:23<00:00, 5.27batch/s, loss=0.313]\n" + "Epoch 8/25: 100%|██████████| 124/124 [00:36<00:00, 3.38it/s, Train Loss=0.697]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 8, Train Loss: 0.4654, Val Loss: 0.6668\n" + "\n", + "Epoch 8, Train Loss: 88.8963, Val Loss: 11.0529\n", + "Train Accuracy: 0.5648, Val Accuracy: 0.6308\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Epoch 9/30: 100%|██████████| 124/124 [00:23<00:00, 5.26batch/s, loss=0.438]\n" + "Epoch 9/25: 100%|██████████| 124/124 [00:37<00:00, 3.34it/s, Train Loss=0.846]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 9, Train Loss: 0.4299, Val Loss: 0.6240\n" + "\n", + "Epoch 9, Train Loss: 88.4877, Val Loss: 11.0292\n", + "Train Accuracy: 0.5706, Val Accuracy: 0.6207\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Epoch 10/30: 100%|██████████| 124/124 [00:23<00:00, 5.23batch/s, loss=0.561]\n" + "Epoch 10/25: 100%|██████████| 124/124 [00:36<00:00, 3.41it/s, Train Loss=0.756]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 10, Train Loss: 0.3863, Val Loss: 0.6328\n" + "\n", + "Epoch 10, Train Loss: 88.5556, Val Loss: 11.0032\n", + "Train Accuracy: 0.5833, Val Accuracy: 0.6308\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "Epoch 11/30: 100%|██████████| 124/124 [00:23<00:00, 5.28batch/s, loss=0.321]\n" + "Epoch 11/25: 100%|██████████| 124/124 [00:36<00:00, 3.41it/s, Train Loss=0.664]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 11, Train Loss: 0.3553, Val Loss: 0.6676\n", - "Early Stopping ausgelöst!\n" + "\n", + "Epoch 11, Train Loss: 88.3764, Val Loss: 10.7751\n", + "Train Accuracy: 0.5706, Val Accuracy: 0.6389\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 12/25: 100%|██████████| 124/124 [00:38<00:00, 3.26it/s, Train Loss=0.866]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 12, Train Loss: 88.9168, Val Loss: 11.1027\n", + "Train Accuracy: 0.5721, Val Accuracy: 0.6085\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 13/25: 100%|██████████| 124/124 [00:39<00:00, 3.13it/s, Train Loss=0.711]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 13, Train Loss: 88.4298, Val Loss: 11.0765\n", + "Train Accuracy: 0.5888, Val Accuracy: 0.6288\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 14/25: 100%|██████████| 124/124 [00:39<00:00, 3.11it/s, Train Loss=0.728]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 14, Train Loss: 88.7229, Val Loss: 11.1684\n", + "Train Accuracy: 0.5823, Val Accuracy: 0.6349\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 15/25: 100%|██████████| 124/124 [00:37<00:00, 3.28it/s, Train Loss=0.774]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 15, Train Loss: 89.3287, Val Loss: 11.4475\n", + "Train Accuracy: 0.5830, Val Accuracy: 0.6146\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 16/25: 100%|██████████| 124/124 [00:35<00:00, 3.48it/s, Train Loss=0.797]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 16, Train Loss: 85.6701, Val Loss: 10.7575\n", + "Train Accuracy: 0.6175, Val Accuracy: 0.6329\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 17/25: 100%|██████████| 124/124 [00:38<00:00, 3.23it/s, Train Loss=0.649]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 17, Train Loss: 83.7000, Val Loss: 10.7996\n", + "Train Accuracy: 0.6294, Val Accuracy: 0.6166\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 18/25: 100%|██████████| 124/124 [00:37<00:00, 3.31it/s, Train Loss=0.703]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 18, Train Loss: 80.2727, Val Loss: 10.7781\n", + "Train Accuracy: 0.6679, Val Accuracy: 0.6450\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 19/25: 100%|██████████| 124/124 [00:38<00:00, 3.24it/s, Train Loss=0.519]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 19, Train Loss: 73.5981, Val Loss: 11.1218\n", + "Train Accuracy: 0.7113, Val Accuracy: 0.6247\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 20/25: 100%|██████████| 124/124 [00:36<00:00, 3.41it/s, Train Loss=1.05] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 20, Train Loss: 66.4704, Val Loss: 11.3424\n", + "Train Accuracy: 0.7592, Val Accuracy: 0.6227\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 21/25: 100%|██████████| 124/124 [00:25<00:00, 4.90it/s, Train Loss=0.794]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 21, Train Loss: 59.3716, Val Loss: 12.2167\n", + "Train Accuracy: 0.8043, Val Accuracy: 0.6024\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 22/25: 100%|██████████| 124/124 [00:25<00:00, 4.79it/s, Train Loss=0.261]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 22, Train Loss: 48.0339, Val Loss: 13.4658\n", + "Train Accuracy: 0.8525, Val Accuracy: 0.6085\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 23/25: 100%|██████████| 124/124 [00:23<00:00, 5.23it/s, Train Loss=0.218]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 23, Train Loss: 36.6165, Val Loss: 15.3780\n", + "Train Accuracy: 0.8966, Val Accuracy: 0.5963\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 24/25: 100%|██████████| 124/124 [00:23<00:00, 5.29it/s, Train Loss=0.166] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 24, Train Loss: 29.4375, Val Loss: 21.4867\n", + "Train Accuracy: 0.9202, Val Accuracy: 0.5822\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 25/25: 100%|██████████| 124/124 [00:22<00:00, 5.40it/s, Train Loss=0.209] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 25, Train Loss: 21.5571, Val Loss: 31.7498\n", + "Train Accuracy: 0.9437, Val Accuracy: 0.5578\n" ] } ], "source": [ - "# Geräteauswahl: MPS (für macOS), CUDA (GPU), oder CPU\n", - "if torch.backends.mps.is_available():\n", - " device = torch.device(\"mps\") # Apple MPS für macOS\n", - "elif torch.cuda.is_available():\n", - " device = torch.device(\"cuda\") # NVIDIA CUDA\n", - "else:\n", - " device = torch.device(\"cpu\") # Fallback auf CPU\n", + "# Training\n", + "history = {\n", + " \"train_loss\": [],\n", + " \"val_loss\": [],\n", + " \"train_acc\": [],\n", + " \"val_acc\": [],\n", + "}\n", "\n", - "# Initialisiere das Modell\n", - "model = SingleKernelCNN(embedding_dim=embedding_dim, num_classes=1, kernel_size=5, num_filters=100, dropout=0.5, use_highway=False).to(device)\n", - "\n", - "# Verlustfunktion und Optimierer\n", - "criterion = nn.BCELoss() # Binary Cross Entropy Loss\n", - "optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4) \n", - "\n", - "# Lernraten-Scheduler\n", - "scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=2, verbose=True)\n", - "\n", - "# Trainingseinstellungen\n", - "epochs = 30 # Maximalanzahl an Epochen\n", - "best_val_loss = float('inf')\n", - "patience = 5 # Geduld für Early Stopping\n", - "counter = 0\n", - "\n", - "\n", - "# Liste zum Speichern der Trainingsverluste\n", - "train_losses = []\n", - "\n", - "# Training und Validierung\n", - "for epoch in range(epochs):\n", + "for epoch in range(params[\"epochs\"]):\n", " model.train()\n", - " total_loss = 0\n", - " with tqdm(train_loader, unit=\"batch\", desc=f\"Epoch {epoch+1}/{epochs}\") as tepoch:\n", - " for texts, labels in train_loader:\n", - " texts, labels = texts.to(device), labels.to(device)\n", + " train_loss, correct, total = 0.0, 0, 0\n", + "\n", + " with tqdm(train_loader, desc=f\"Epoch {epoch + 1}/{params['epochs']}\") as pbar:\n", + " for X_batch, y_batch in pbar:\n", + " X_batch, y_batch = X_batch.to(device), y_batch.to(device)\n", " optimizer.zero_grad()\n", - " outputs = model(texts)\n", - " loss = criterion(outputs, labels)\n", + " outputs = model(X_batch)\n", + " loss = criterion(outputs, y_batch)\n", " loss.backward()\n", " optimizer.step()\n", - " total_loss += loss.item()\n", - " tepoch.update(1)\n", - " tepoch.set_postfix(loss=loss.item())\n", - " \n", - " avg_train_loss = total_loss / len(train_loader)\n", - " train_losses.append(avg_train_loss) # Speichere den Trainingsverlust\n", - " \n", - " # Validierung\n", + "\n", + " train_loss += loss.item()\n", + " predicted = torch.argmax(outputs, dim=1)\n", + " correct += (predicted == y_batch).sum().item()\n", + " total += y_batch.size(0)\n", + "\n", + " pbar.set_postfix({\"Train Loss\": loss.item()})\n", + "\n", + " train_acc = correct / total\n", + " history[\"train_loss\"].append(train_loss / len(train_loader))\n", + " history[\"train_acc\"].append(train_acc)\n", + "\n", + " # Validation\n", " model.eval()\n", - " val_loss = 0\n", + " val_loss, correct, total = 0.0, 0, 0\n", " with torch.no_grad():\n", - " for texts, labels in val_loader:\n", - " texts, labels = texts.to(device), labels.to(device)\n", - " outputs = model(texts)\n", - " loss = criterion(outputs, labels)\n", + " for X_batch, y_batch in val_loader:\n", + " X_batch, y_batch = X_batch.to(device), y_batch.to(device)\n", + " outputs = model(X_batch)\n", + " loss = criterion(outputs, y_batch)\n", " val_loss += loss.item()\n", - " \n", - " avg_val_loss = val_loss / len(val_loader)\n", - " scheduler.step(avg_val_loss)\n", + " predicted = torch.argmax(outputs, dim=1)\n", + " correct += (predicted == y_batch).sum().item()\n", + " total += y_batch.size(0)\n", "\n", - " print(f\"Epoch {epoch+1}, Train Loss: {avg_train_loss:.4f}, Val Loss: {avg_val_loss:.4f}\")\n", + " val_acc = correct / total\n", + " history[\"val_loss\"].append(val_loss / len(val_loader))\n", + " history[\"val_acc\"].append(val_acc)\n", "\n", - " # Early Stopping\n", - " if avg_val_loss < best_val_loss:\n", - " best_val_loss = avg_val_loss\n", - " counter = 0\n", - " torch.save(model.state_dict(), \"best_model.pth\")\n", - " else:\n", - " counter += 1\n", - " if counter >= patience:\n", - " print(\"Early Stopping ausgelöst!\")\n", - " break" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Trainingsverlust" + " print(f\"\\nEpoch {epoch + 1}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}\")\n", + " print(f\"Train Accuracy: {train_acc:.4f}, Val Accuracy: {val_acc:.4f}\")" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 84, "metadata": {}, "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Plot: Trainingsverlust über die Epochen\n", - "plt.figure(figsize=(8, 5))\n", - "plt.plot(range(1, len(train_losses) + 1), train_losses, label=\"Trainingsverlust\", marker='o')\n", - "plt.xlabel(\"Epochen\")\n", - "plt.ylabel(\"Verlust\")\n", - "plt.title(\"Trainingsverlust über die Epochen\")\n", - "plt.grid(True)\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "### Finale Evaluierung & Confusion Matrix\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_5620/1822405546.py:2: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", - " model.load_state_dict(torch.load(\"best_model.pth\"))\n" - ] - }, { "name": "stdout", "output_type": "stream", "text": [ - "🚀 Finale Test Accuracy: 0.6518\n", - "🚀 Finale Test F1 Score: 0.6993\n" + "Test Accuracy: 0.6235\n" ] } ], "source": [ - "# Testen des Modells\n", - "model.load_state_dict(torch.load(\"best_model.pth\"))\n", + "# Testen und Visualisieren\n", "model.eval()\n", - "all_preds = []\n", - "all_labels = []\n", + "test_correct, test_total = 0, 0\n", + "all_labels, all_preds = [], []\n", "\n", "with torch.no_grad():\n", - " for texts, labels in test_loader:\n", - " texts, labels = texts.to(device), labels.to(device)\n", - " outputs = model(texts)\n", - " predictions = (outputs > 0.5).float()\n", - " all_preds.extend(predictions.cpu().numpy())\n", - " all_labels.extend(labels.cpu().numpy())\n", + " for X_batch, y_batch in test_loader:\n", + " X_batch, y_batch = X_batch.to(device), y_batch.to(device)\n", + " outputs = model(X_batch)\n", + " predicted = torch.argmax(outputs, dim=1)\n", + " all_labels.extend(y_batch.cpu().numpy())\n", + " all_preds.extend(predicted.cpu().numpy())\n", + " test_correct += (predicted == y_batch).sum().item()\n", + " test_total += y_batch.size(0)\n", "\n", - "all_preds = [int(p[0]) for p in all_preds]\n", - "all_labels = [int(l[0]) for l in all_labels]\n", - "\n", - "# Test-Accuracy und F1-Score berechnen\n", - "accuracy = accuracy_score(all_labels, all_preds)\n", - "f1 = f1_score(all_labels, all_preds)\n", - "\n", - "print(f'🚀 Finale Test Accuracy: {accuracy:.4f}')\n", - "print(f'🚀 Finale Test F1 Score: {f1:.4f}')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Konfusionsmatrix" + "test_accuracy = test_correct / test_total\n", + "print(f\"Test Accuracy: {test_accuracy:.4f}\")\n" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 85, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "🚀 Finale Test Accuracy: 0.6235\n", + "🚀 Finale Test F1 Score: 0.6189\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -503,15 +721,104 @@ } ], "source": [ - "# Konfusionsmatrix visualisieren\n", - "conf_matrix = confusion_matrix(all_labels, all_preds)\n", + "import ml_evaluation as ml_eval\n", "\n", - "plt.figure(figsize=(6,5))\n", - "sns.heatmap(conf_matrix, annot=True, fmt='d', cmap=\"Blues\", xticklabels=['No Humor', 'Humor'], yticklabels=['No Humor', 'Humor'])\n", - "plt.xlabel(\"Predicted Label\")\n", - "plt.ylabel(\"True Label\")\n", - "plt.title(\"Confusion Matrix\")\n", - "plt.show()\n" + "print(f'🚀 Finale Test Accuracy: {ml_eval.get_accuracy(all_preds, all_labels):.4f}')\n", + "print(f'🚀 Finale Test F1 Score: {ml_eval.get_f1_score(all_preds, all_labels):.4f}')\n", + "\n", + "# Confusion matrix\n", + "con_plt = ml_eval.plot_confusion_matrix(all_preds, all_labels, ['0', '1'])\n", + "con_plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Class 0: 0.44\n", + "Class 1: 0.56\n" + ] + } + ], + "source": [ + "ml_eval.get_label_distribution(all_labels, all_preds)" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import ml_evaluation as ml_eval\n", + "ml_eval.plot_rating_preds(all_preds, all_labels, test_dataset).show()" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_distribution(true_values, predicted_values):\n", + " plt.figure(figsize=(10, 6))\n", + "\n", + " # Häufigkeiten der Klassen berechnen\n", + " true_counts = np.bincount(true_values, minlength=2)\n", + " predicted_counts = np.bincount(predicted_values, minlength=2)\n", + "\n", + " # Barplot erstellen\n", + " labels = ['No Humor', 'Humor']\n", + " x = np.arange(len(labels))\n", + "\n", + " plt.bar(x - 0.2, true_counts, width=0.4, color='skyblue', label='Wahre Werte', edgecolor='black')\n", + " plt.bar(x + 0.2, predicted_counts, width=0.4, color='salmon', label='Vorhergesagte Werte', edgecolor='black')\n", + "\n", + " plt.title('Verteilung der wahren Werte und Vorhersagen')\n", + " plt.xticks(x, labels)\n", + " plt.ylabel('Häufigkeit')\n", + " plt.xlabel('Klassen')\n", + " plt.legend()\n", + " plt.grid(axis='y', linestyle='--', alpha=0.7)\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualisierung der Verteilung (Barplot)\n", + "visualize_distribution(all_labels, all_preds)" ] } ], diff --git a/cnn_reg.ipynb b/cnn_reg.ipynb index b2d4225..09bda75 100644 --- a/cnn_reg.ipynb +++ b/cnn_reg.ipynb @@ -9,22 +9,31 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", - "import torch.nn.functional as F\n", + "import torch.optim as optim\n", "from torch.utils.data import DataLoader\n", - "from tqdm import tqdm # Fortschrittsbalken\n", + "from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score\n", + "from tqdm import tqdm # Fortschrittsbalken-Bibliothek\n", + "from dataset_generator import create_embedding_matrix, split_data\n", + "from HumorDataset import TextRegDataset\n", "import numpy as np\n", + "import pandas as pd\n", + "import os\n", "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n", "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np" + "# lokal imports\n", + "import ml_evaluation as ml_eval\n", + "import ml_helper\n", + "import ml_history\n", + "import dataset_generator as data_gen\n", + "# class imports\n", + "import HumorDataset as humor_ds\n", + "import EarlyStopping as EarlyStopping\n" ] }, { @@ -33,74 +42,46 @@ "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_46830/3644220936.py:6: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", - " train_dataset = torch.load(data_path + '/train.pt')\n", - "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_46830/3644220936.py:7: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", - " test_dataset = torch.load(data_path + '/test.pt')\n", - "/var/folders/l7/061cw0t95vz1myntpf9bj9540000gn/T/ipykernel_46830/3644220936.py:8: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", - " val_dataset = torch.load(data_path + '/val.pt')\n" + "Using device: mps\n" ] } ], "source": [ - "# Daten laden\n", + "torch.manual_seed(0)\n", + "np.random.seed(0)\n", "\n", - "data_path = 'data/embedded_padded'\n", - "BATCH_SIZE = 32\n", "\n", - "train_dataset = torch.load(data_path + '/train.pt')\n", - "test_dataset = torch.load(data_path + '/test.pt')\n", - "val_dataset = torch.load(data_path + '/val.pt')\n", + "best_model_filename = 'best_cnn_reg_model.pt'\n", "\n", - "# DataLoader vorbereiten\n", - "def collate_fn(batch):\n", - " input_ids = torch.stack([item[\"input_ids\"] for item in batch]) \n", - " labels = torch.tensor([item[\"labels\"] for item in batch], dtype=torch.float32).unsqueeze(1) \n", - " return input_ids, labels\n", - "\n", - "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_fn)\n", - "val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False, collate_fn=collate_fn)\n", - "test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, shuffle=False, collate_fn=collate_fn)\n" + "device = ml_helper.get_device(verbose=True)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/michellegoppinger/Documents/Dokumente – Laptop von Michelle/Uni/Master/ANLP/ANLP_WS24_CA2/HumorDataset.py:56: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/utils/tensor_new.cpp:281.)\n", - " item = {'input_ids': torch.tensor(self.data[idx], dtype=torch.float)}\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# Labels extrahieren und in eine Liste konvertieren\n", - "train_labels = [item[\"labels\"].item() for item in train_dataset] \n", - "\n", - "# Verteilung der Labels visualisieren\n", - "plt.figure(figsize=(8, 6))\n", - "sns.histplot(train_labels, bins=20)\n", - "plt.xlabel(\"Humor Scores\")\n", - "plt.ylabel(\"Frequency\")\n", - "plt.title(\"Verteilung der Trainingslabels\")\n", - "plt.show()\n" + "# Hyperparameter und Konfigurationen\n", + "params = {\n", + " \"embedding_dim\": 100,\n", + " \"filter_sizes\": [2, 3, 4, 5], # Zusätzliche Filtergröße\n", + " \"num_filters\": 150, # Erhöhte Anzahl von Filtern\n", + " \"batch_size\": 32,\n", + " \"learning_rate\": 0.001,\n", + " \"epochs\": 25,\n", + " \"glove_path\": 'data/glove.6B.100d.txt', # Pfad zu GloVe\n", + " \"max_len\": 280,\n", + " \"test_size\": 0.1,\n", + " \"val_size\": 0.1,\n", + " \"patience\": 5,\n", + " \"data_path\": 'data/hack.csv', # Pfad zu den Daten\n", + " \"dropout\": 0.6, # Erhöhtes Dropout\n", + " \"weight_decay\": 5e-4 # L2-Regularisierung\n", + "}" ] }, { @@ -109,18 +90,35 @@ "metadata": {}, "outputs": [], "source": [ - "class WeightedMSELoss(nn.Module):\n", - " def __init__(self, weights):\n", - " super(WeightedMSELoss, self).__init__()\n", - " self.weights = weights\n", + "class CNNRegressor(nn.Module):\n", + " def __init__(self, vocab_size, embedding_dim, filter_sizes, num_filters, embedding_matrix, dropout):\n", + " super(CNNRegressor, self).__init__()\n", + " self.embedding = nn.Embedding.from_pretrained(embedding_matrix, freeze=False)\n", + " \n", + " # Convolutional Schichten mit Batch-Normalisierung\n", + " self.convs = nn.ModuleList([\n", + " nn.Sequential(\n", + " nn.Conv2d(1, num_filters, (fs, embedding_dim)),\n", + " nn.BatchNorm2d(num_filters), # Batch-Normalisierung\n", + " nn.ReLU(),\n", + " nn.MaxPool2d((params[\"max_len\"] - fs + 1, 1)),\n", + " nn.Dropout(dropout) # Dropout nach jeder Schicht\n", + " )\n", + " for fs in filter_sizes\n", + " ])\n", + " \n", + " # Fully-Connected Layer\n", + " self.fc1 = nn.Linear(len(filter_sizes) * num_filters, 128) # Erweiterte Dense-Schicht\n", + " self.fc2 = nn.Linear(128, 1) # Ausgangsschicht (Regression)\n", + " self.dropout = nn.Dropout(dropout)\n", "\n", - " def forward(self, inputs, targets):\n", - " weights = self.weights[targets.long()]\n", - " loss = weights * (inputs - targets) ** 2\n", - " return loss.mean()\n", - "\n", - "# Gewichtung basierend auf Seltenheit der Zwischenwerte\n", - "weights = torch.tensor([2.0 if 0.2 <= x <= 0.8 else 1.0 for x in range(2)], dtype=torch.float32)\n" + " def forward(self, x):\n", + " x = self.embedding(x).unsqueeze(1) # [Batch, 1, Seq, Embedding]\n", + " conv_outputs = [conv(x).squeeze(3).squeeze(2) for conv in self.convs] # Pooling reduziert Dim\n", + " x = torch.cat(conv_outputs, 1) # Kombiniere Features von allen Filtern\n", + " x = torch.relu(self.fc1(x)) # Zusätzliche Dense-Schicht\n", + " x = self.dropout(x)\n", + " return self.fc2(x).squeeze(1)\n" ] }, { @@ -129,47 +127,27 @@ "metadata": {}, "outputs": [], "source": [ - "class CNN_HumorRegressor(nn.Module):\n", - " def __init__(self, embed_dim, filter_sizes, num_filters, dropout=0.5):\n", - " super(CNN_HumorRegressor, self).__init__()\n", + "# Funktion zum Laden und Vorverarbeiten der Daten\n", + "def load_preprocess_data(path_data='data/hack.csv'):\n", + " # Daten laden\n", + " df = pd.read_csv(path_data)\n", "\n", - " # Convolutional Layers mit verschiedenen Filtergrößen\n", - " self.convs = nn.ModuleList([\n", - " nn.Conv2d(in_channels=1, out_channels=num_filters, kernel_size=(fs, embed_dim)) \n", - " for fs in filter_sizes\n", - " ])\n", + " # Fehlende Werte in der Zielspalte entfernen\n", + " df = df.dropna(subset=['humor_rating'])\n", "\n", - " # Highway-Netzwerk für bessere Feature-Extraktion\n", - " self.highway = nn.Linear(len(filter_sizes) * num_filters, len(filter_sizes) * num_filters)\n", + " # Zielvariable aus der Spalte 'humor_rating' extrahieren\n", + " df['y'] = df['humor_rating'].astype(float) # Sicherstellen, dass Zielvariable numerisch ist\n", "\n", - " # Dropout zur Vermeidung von Overfitting\n", - " self.dropout = nn.Dropout(dropout)\n", + " # Eingabetexte und Zielvariable zuweisen\n", + " X = df['text']\n", + " y = df['y']\n", "\n", - " # Fully Connected Layers\n", - " self.fc1 = nn.Linear(len(filter_sizes) * num_filters, 256)\n", - " self.fc2 = nn.Linear(256, 128)\n", - " self.fc3 = nn.Linear(128, 1)\n", - "\n", - " def forward(self, x):\n", - " x = x.unsqueeze(1) # [Batch Size, 1, Seq Length, Embed Dim]\n", - "\n", - " # Convolution + ReLU activation\n", - " conved = [F.relu(conv(x)).squeeze(3) for conv in self.convs]\n", - "\n", - " # Max-Pooling über jede Feature-Map\n", - " pooled = [F.max_pool1d(c, c.size(2)).squeeze(2) for c in conved]\n", - "\n", - " # Feature-Vektor kombinieren\n", - " cat = torch.cat(pooled, dim=1)\n", - "\n", - " # Highway-Netzwerk\n", - " highway = F.relu(self.highway(cat))\n", - " highway = self.dropout(highway + cat)\n", - "\n", - " # Fully Connected Layers\n", - " fc_out = F.relu(self.fc1(highway))\n", - " fc_out = F.relu(self.fc2(fc_out))\n", - " return torch.sigmoid(self.fc3(fc_out)) # Sigmoid für Wertebereich [0, 1]\n" + " # Debug-Ausgabe zur Überprüfung\n", + " print(f\"Erste Zielwerte: {y.head(10)}\")\n", + " print(f\"Datentyp der Zielvariable: {y.dtype}\")\n", + " print(f\"Anzahl der Beispiele: {len(X)}\")\n", + " \n", + " return X, y" ] }, { @@ -178,62 +156,72 @@ "metadata": {}, "outputs": [], "source": [ - "EMBED_DIM = train_dataset[0][\"input_ids\"].shape[1]\n", - "FILTER_SIZES = [2, 3, 4, 5]\n", - "NUM_FILTERS = 300\n", - "DROPOUT = 0.5\n", - "LR = 0.001\n", - "EPOCHS = 10\n", - "\n", - "device = torch.device(\"mps\" if torch.backends.mps.is_available() else \"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "\n", - "# Modell initialisieren\n", - "model = CNN_HumorRegressor(EMBED_DIM, FILTER_SIZES, NUM_FILTERS, DROPOUT).to(device)\n", - "\n", - "# Gewichtete Verlustfunktion und Optimierer\n", - "criterion = WeightedMSELoss(weights.to(device))\n", - "optimizer = torch.optim.Adam(model.parameters(), lr=LR)\n" + "# Visualisierung der Zielvariablen (Scores)\n", + "def visualize_data_distribution(y):\n", + " print(\"\\n--- Zielvariable: Statistik ---\")\n", + " print(f\"Min: {np.min(y)}, Max: {np.max(y)}\")\n", + " print(f\"Mittelwert: {np.mean(y):.4f}, Standardabweichung: {np.std(y):.4f}\")\n", + " \n", + " # Histogramm plotten\n", + " plt.figure(figsize=(10, 6))\n", + " plt.hist(y, bins=20, color='skyblue', edgecolor='black')\n", + " plt.title('Verteilung der Zielvariable (Scores)')\n", + " plt.xlabel('Score')\n", + " plt.ylabel('Häufigkeit')\n", + " plt.grid(axis='y', linestyle='--', alpha=0.7)\n", + " plt.show()\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "400002\n", + "vocab_size: 400002, d_model: 100\n", + "Erste Zielwerte: 0 2.42\n", + "1 2.50\n", + "2 1.95\n", + "3 2.11\n", + "4 2.78\n", + "7 1.79\n", + "11 2.20\n", + "12 1.50\n", + "13 2.16\n", + "17 1.78\n", + "Name: y, dtype: float64\n", + "Datentyp der Zielvariable: float64\n", + "Anzahl der Beispiele: 4932\n", + "\n", + "--- Zielvariable: Statistik ---\n", + "Min: 0.1, Max: 4.0\n", + "Mittelwert: 2.2605, Standardabweichung: 0.5669\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "def train_model(model, train_loader, val_loader, criterion, optimizer, epochs, device):\n", - " for epoch in range(epochs):\n", - " model.train()\n", - " total_loss = 0\n", + "# Daten laden und vorbereiten\n", + "embedding_matrix, word_index, vocab_size, d_model = create_embedding_matrix(\n", + " gloVe_path=params[\"glove_path\"], emb_len=params[\"embedding_dim\"]\n", + ")\n", + "X, y = load_preprocess_data(path_data=params[\"data_path\"])\n", "\n", - " # Fortschrittsbalken für das Training\n", - " with tqdm(train_loader, unit=\"batch\", desc=f\"Epoch {epoch+1}/{epochs}\") as tepoch:\n", - " for inputs, labels in tepoch:\n", - " inputs, labels = inputs.to(device), labels.to(device)\n", - "\n", - " optimizer.zero_grad()\n", - " outputs = model(inputs)\n", - " loss = criterion(outputs, labels)\n", - " loss.backward()\n", - " optimizer.step()\n", - "\n", - " total_loss += loss.item()\n", - " tepoch.set_postfix(loss=loss.item())\n", - "\n", - " val_loss = evaluate(model, val_loader, criterion, device)\n", - " print(f\"Epoch {epoch+1}/{epochs} - Train Loss: {total_loss:.4f} - Val Loss: {val_loss:.4f}\")\n", - "\n", - "def evaluate(model, test_loader, criterion, device):\n", - " model.eval()\n", - " total_loss = 0\n", - " with tqdm(test_loader, unit=\"batch\", desc=\"Evaluating\") as tepoch:\n", - " with torch.no_grad():\n", - " for inputs, labels in tepoch:\n", - " inputs, labels = inputs.to(device), labels.to(device)\n", - " outputs = model(inputs)\n", - " loss = criterion(outputs, labels)\n", - " total_loss += loss.item()\n", - " return total_loss / len(test_loader)\n" + "# Visualisierung der Daten\n", + "visualize_data_distribution(y)" ] }, { @@ -241,297 +229,450 @@ "execution_count": 8, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Epoch 1/10: 0%| | 0/124 [00:00 0.744646). Saving model ...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "\n" + "Epoch 2/25: 100%|██████████| 124/124 [00:19<00:00, 6.44it/s, Train Loss=0.696]\n" ] - } - ], - "source": [ - "test_loss = evaluate(model, test_loader, criterion, device)\n", - "print(f\"Test Loss (MSE): {test_loss:.4f}\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ + }, { "name": "stdout", "output_type": "stream", "text": [ - "Evaluation Metrics on Test Data:\n", - "Mean Squared Error (MSE): 0.3358\n", - "Root Mean Squared Error (RMSE): 0.5795\n", - "Mean Absolute Error (MAE): 0.3900\n", - "R² Score: -0.3445\n" + "\n", + "Epoch 2, Train Loss: 98.9154, Val Loss: 9.4178\n", + "Train RMSE: 0.8935, Val RMSE: 0.7682\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 3/25: 100%|██████████| 124/124 [00:19<00:00, 6.30it/s, Train Loss=1.79] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 3, Train Loss: 93.6001, Val Loss: 7.3193\n", + "Train RMSE: 0.8653, Val RMSE: 0.6769\n", + "Validation loss decreased (-0.676914 --> 0.676914). Saving model ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 4/25: 100%|██████████| 124/124 [00:18<00:00, 6.58it/s, Train Loss=1.12] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 4, Train Loss: 83.3528, Val Loss: 6.1189\n", + "Train RMSE: 0.8183, Val RMSE: 0.6187\n", + "Validation loss decreased (-0.618719 --> 0.618719). Saving model ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 5/25: 100%|██████████| 124/124 [00:19<00:00, 6.20it/s, Train Loss=0.866]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 5, Train Loss: 82.4167, Val Loss: 6.3834\n", + "Train RMSE: 0.8145, Val RMSE: 0.6317\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 6/25: 100%|██████████| 124/124 [00:20<00:00, 6.13it/s, Train Loss=0.528]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 6, Train Loss: 76.5571, Val Loss: 6.5987\n", + "Train RMSE: 0.7861, Val RMSE: 0.6421\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 7/25: 100%|██████████| 124/124 [00:20<00:00, 6.13it/s, Train Loss=0.135]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 7, Train Loss: 73.0328, Val Loss: 6.4774\n", + "Train RMSE: 0.7692, Val RMSE: 0.6361\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 8/25: 100%|██████████| 124/124 [00:20<00:00, 6.07it/s, Train Loss=0.5] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 8, Train Loss: 73.0788, Val Loss: 5.5935\n", + "Train RMSE: 0.7680, Val RMSE: 0.5913\n", + "Validation loss decreased (-0.591316 --> 0.591316). Saving model ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 9/25: 100%|██████████| 124/124 [00:20<00:00, 6.00it/s, Train Loss=0.747]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 9, Train Loss: 72.9909, Val Loss: 5.7356\n", + "Train RMSE: 0.7666, Val RMSE: 0.5987\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 10/25: 100%|██████████| 124/124 [00:20<00:00, 6.07it/s, Train Loss=0.33] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 10, Train Loss: 68.4401, Val Loss: 5.6286\n", + "Train RMSE: 0.7438, Val RMSE: 0.5931\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 11/25: 100%|██████████| 124/124 [00:21<00:00, 5.90it/s, Train Loss=0.135]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 11, Train Loss: 72.3024, Val Loss: 6.8619\n", + "Train RMSE: 0.7653, Val RMSE: 0.6543\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 12/25: 100%|██████████| 124/124 [00:20<00:00, 5.98it/s, Train Loss=0.353]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 12, Train Loss: 65.9048, Val Loss: 6.5378\n", + "Train RMSE: 0.7297, Val RMSE: 0.6390\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 13/25: 100%|██████████| 124/124 [00:22<00:00, 5.55it/s, Train Loss=0.4] \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 13, Train Loss: 65.4947, Val Loss: 5.1140\n", + "Train RMSE: 0.7273, Val RMSE: 0.5665\n", + "Validation loss decreased (-0.566452 --> 0.566452). Saving model ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 14/25: 100%|██████████| 124/124 [00:23<00:00, 5.21it/s, Train Loss=0.515]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 14, Train Loss: 62.4101, Val Loss: 6.0987\n", + "Train RMSE: 0.7094, Val RMSE: 0.6177\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 15/25: 100%|██████████| 124/124 [00:23<00:00, 5.38it/s, Train Loss=0.645]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 15, Train Loss: 64.4443, Val Loss: 9.2568\n", + "Train RMSE: 0.7204, Val RMSE: 0.7601\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 16/25: 100%|██████████| 124/124 [00:24<00:00, 5.15it/s, Train Loss=0.288]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 16, Train Loss: 58.4627, Val Loss: 5.3123\n", + "Train RMSE: 0.6874, Val RMSE: 0.5776\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 17/25: 100%|██████████| 124/124 [00:22<00:00, 5.43it/s, Train Loss=0.524]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 17, Train Loss: 58.4355, Val Loss: 5.5252\n", + "Train RMSE: 0.6863, Val RMSE: 0.5889\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 18/25: 100%|██████████| 124/124 [00:21<00:00, 5.74it/s, Train Loss=0.223]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Epoch 18, Train Loss: 55.3765, Val Loss: 5.9419\n", + "Train RMSE: 0.6692, Val RMSE: 0.6100\n", + "Early stopping triggered.\n" ] } ], "source": [ - "def evaluate_metrics(model, test_loader, device):\n", + "\n", + "# Speicher für Trainingsmetriken\n", + "history = {\n", + " \"train_loss\": [],\n", + " \"val_loss\": [],\n", + " \"train_rmse\": [],\n", + " \"val_rmse\": [],\n", + "}\n", + "\n", + "# Training und Validierung\n", + "for epoch in range(params[\"epochs\"]):\n", + " model.train()\n", + " train_loss = 0.0\n", + " train_preds, train_labels = [], []\n", + "\n", + " # Fortschrittsbalken für Training innerhalb einer Epoche\n", + " with tqdm(train_loader, desc=f\"Epoch {epoch + 1}/{params['epochs']}\") as pbar:\n", + " for X_batch, y_batch in pbar:\n", + " X_batch, y_batch = X_batch.to(device), y_batch.to(device).float()\n", + " optimizer.zero_grad()\n", + " predictions = model(X_batch).float()\n", + " loss = criterion(predictions, y_batch)\n", + " loss.backward()\n", + " optimizer.step()\n", + " train_loss += loss.item()\n", + " \n", + " # Speichere echte und vorhergesagte Werte für Metriken\n", + " train_preds.extend(predictions.cpu().detach().numpy())\n", + " train_labels.extend(y_batch.cpu().detach().numpy())\n", + " \n", + " # Update der Fortschrittsanzeige\n", + " pbar.set_postfix({\"Train Loss\": loss.item()})\n", + " \n", + " train_rmse = np.sqrt(mean_squared_error(train_labels, train_preds)) # RMSE\n", + " history[\"train_loss\"].append(train_loss / len(train_loader))\n", + " history[\"train_rmse\"].append(train_rmse)\n", + "\n", + " # Validation\n", " model.eval()\n", - " predictions = []\n", - " actuals = []\n", + " val_loss = 0.0\n", + " val_preds, val_labels = [], []\n", " with torch.no_grad():\n", - " for inputs, labels in test_loader:\n", - " inputs, labels = inputs.to(device), labels.to(device)\n", - " outputs = model(inputs)\n", - " predictions.extend(outputs.cpu().numpy().flatten())\n", - " actuals.extend(labels.cpu().numpy().flatten())\n", + " for X_batch, y_batch in val_loader:\n", + " X_batch, y_batch = X_batch.to(device), y_batch.to(device).float()\n", + " predictions = model(X_batch).float()\n", + " loss = criterion(predictions, y_batch)\n", + " val_loss += loss.item()\n", "\n", - " mse = mean_squared_error(actuals, predictions)\n", - " rmse = np.sqrt(mse)\n", - " mae = mean_absolute_error(actuals, predictions)\n", - " r2 = r2_score(actuals, predictions)\n", + " val_preds.extend(predictions.cpu().detach().numpy())\n", + " val_labels.extend(y_batch.cpu().detach().numpy())\n", "\n", - " return mse, rmse, mae, r2, actuals, predictions\n", + " val_rmse = np.sqrt(mean_squared_error(val_labels, val_preds)) # RMSE\n", + " history[\"val_loss\"].append(val_loss / len(val_loader))\n", + " history[\"val_rmse\"].append(val_rmse)\n", "\n", - "mse, rmse, mae, r2, actuals, predictions = evaluate_metrics(model, test_loader, device)\n", + " print(f\"\\nEpoch {epoch + 1}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}\")\n", + " print(f\"Train RMSE: {train_rmse:.4f}, Val RMSE: {val_rmse:.4f}\")\n", "\n", - "print(\"Evaluation Metrics on Test Data:\")\n", - "print(f\"Mean Squared Error (MSE): {mse:.4f}\")\n", - "print(f\"Root Mean Squared Error (RMSE): {rmse:.4f}\")\n", - "print(f\"Mean Absolute Error (MAE): {mae:.4f}\")\n", - "print(f\"R² Score: {r2:.4f}\")\n", - "\n" + " early_stopping(val_rmse, model)\n", + " if early_stopping.early_stop:\n", + " print(\"Early stopping triggered.\")\n", + " break\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "# Definiere korrekte und falsche Vorhersagen basierend auf einem Schwellenwert\n", - "threshold = 0.5\n", - "predicted_labels = (np.array(predictions) > threshold).astype(int)\n", - "true_labels = (np.array(actuals) > threshold).astype(int)\n", + "# Plot-Funktion für Training\n", + "def plot_learning_curves(history):\n", + " epochs = range(1, len(history['train_loss']) + 1)\n", "\n", - "# Bool-Array für korrekte Vorhersagen\n", - "correct = predicted_labels == true_labels\n", + " # Loss-Plot\n", + " plt.figure(figsize=(14, 6))\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(epochs, history['train_loss'], label='Train Loss')\n", + " plt.plot(epochs, history['val_loss'], label='Val Loss')\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Loss')\n", + " plt.title('Training and Validation Loss')\n", + " plt.legend()\n", "\n", - "# Farben zuordnen: Grün für korrekt, Rot für falsch\n", - "colors = ['green' if is_correct else 'red' for is_correct in correct]\n", + " # RMSE-Plot\n", + " plt.subplot(1, 2, 2)\n", + " plt.plot(epochs, history['train_rmse'], label='Train RMSE')\n", + " plt.plot(epochs, history['val_rmse'], label='Val RMSE')\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('RMSE')\n", + " plt.title('Training and Validation RMSE')\n", + " plt.legend()\n", "\n", - "# Scatter-Plot\n", - "plt.figure(figsize=(8, 6))\n", - "plt.scatter(actuals, predictions, c=colors, alpha=0.6, edgecolor='k')\n", - "\n", - "\n", - "# Legende anpassen\n", - "import matplotlib.patches as mpatches\n", - "green_patch = mpatches.Patch(color='green', label='Correct Predictions')\n", - "red_patch = mpatches.Patch(color='red', label='Incorrect Predictions')\n", - "plt.legend(handles=[green_patch, red_patch])\n", - "\n", - "# Achsen und Titel\n", - "plt.title('True vs. Predicted Humor Scores')\n", - "plt.xlabel('True Humor Score')\n", - "plt.ylabel('Predicted Humor Score')\n", - "plt.show()\n" + " plt.tight_layout()\n", + " plt.show()\n" ] }, { @@ -539,18 +680,11 @@ "execution_count": 15, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "239\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -558,38 +692,143 @@ } ], "source": [ - "import pandas as pd\n", + "# Plot der Lernkurven\n", + "plot_learning_curves(history)\n", + "# Funktion zur Visualisierung der richtigen und falschen Vorhersagen\n", + "def visualize_predictions(true_values, predicted_values):\n", + " plt.figure(figsize=(10, 6))\n", + " \n", + " # Unterschied zwischen vorhergesagten und wahren Werten\n", + " correct_indices = np.isclose(true_values, predicted_values, atol=0.3) # Als korrekt angenommen, wenn Differenz <= 0.3\n", + " \n", + " # Plot\n", + " plt.scatter(true_values[correct_indices], predicted_values[correct_indices], color='green', label='Richtig vorhergesagt')\n", + " plt.scatter(true_values[~correct_indices], predicted_values[~correct_indices], color='red', label='Falsch vorhergesagt')\n", + " plt.plot([min(true_values), max(true_values)], [min(true_values), max(true_values)], color='blue', linestyle='--', label='Ideal-Linie')\n", + " \n", + " plt.xlabel('Wahre Werte')\n", + " plt.ylabel('Vorhergesagte Werte')\n", + " plt.title('Richtige vs Falsche Vorhersagen')\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# Test Evaluation\n", + "model.eval()\n", + "test_preds, test_labels = [], []\n", + "with torch.no_grad():\n", + " for X_batch, y_batch in test_loader:\n", + " X_batch, y_batch = X_batch.to(device), y_batch.to(device).float()\n", + " predictions = model(X_batch).float()\n", + " test_preds.extend(predictions.cpu().detach().numpy())\n", + " test_labels.extend(y_batch.cpu().detach().numpy())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Konvertierung zu NumPy-Arrays\n", + "true_values = np.array(test_labels)\n", + "predicted_values = np.array(test_preds)\n", "\n", - "# Load the data from csv\n", - "df = pd.read_csv('data/hack.csv')\n", - "df_test = df.iloc[test_dataset.original_indices].copy()\n", - "df_test['prediction'] = predicted_labels\n", - "df_test['label'] = true_labels\n", - "df_test['pred_correct'] = (df_test['prediction'] == df_test['label'])\n", - "\n", - "df_test_sorted = df_test.sort_values(by='humor_rating').reset_index(drop=True)\n", - "\n", - "from matplotlib import patches as mpatches\n", - "\n", - "median_rating = df['humor_rating'].median()\n", - "# get first index where humor_rating is greater than median_rating\n", - "median_idx = df_test_sorted[df_test_sorted['humor_rating'] > median_rating].index[0]\n", - "print(median_idx)\n", - "# range idx for len df_test\n", - "range_idx = range(len(df_test))\n", - "colors = df_test_sorted['pred_correct'].map({True: 'g', False: 'r'})\n", - "# bar plot for each df_test humor_rating value \n", - "plt.bar(range_idx, df_test_sorted['humor_rating'], color=colors)\n", - "# vertical line for True/False cut off\n", - "plt.axvline(x=median_idx, color='black', linestyle='--')\n", - "# Create a legend handles\n", - "green_patch = mpatches.Patch(color='g', label='Correct Prediction')\n", - "red_patch = mpatches.Patch(color='r', label='Incorrect Prediction')\n", - "line_patch = mpatches.Patch(color='black', label='humor_rating cut off')\n", - "plt.title('Humor Rating vs Prediction for Test Set')\n", - "plt.xlabel('Index')\n", - "plt.ylabel('Humor Rating')\n", - "plt.legend(handles=[green_patch, red_patch, line_patch])\n", + "# Visualisierung der Ergebnisse\n", + "visualize_predictions(true_values, predicted_values)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test RMSE: 0.5820, Test MAE: 0.4757, Test R²: -0.0582\n" + ] + } + ], + "source": [ + "# RMSE, MAE und R²-Score für das Test-Set\n", + "test_rmse = np.sqrt(mean_squared_error(test_labels, test_preds))\n", + "test_mae = mean_absolute_error(test_labels, test_preds)\n", + "test_r2 = r2_score(test_labels, test_preds)\n", + "print(f\"Test RMSE: {test_rmse:.4f}, Test MAE: {test_mae:.4f}, Test R²: {test_r2:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "# Funktion zur Visualisierung der richtigen und falschen Vorhersagen\n", + "def visualize_predictions(true_values, predicted_values):\n", + " plt.figure(figsize=(10, 6))\n", + " \n", + " # Unterschied zwischen vorhergesagten und wahren Werten\n", + " correct_indices = np.isclose(true_values, predicted_values, atol=0.3) # Als korrekt angenommen, wenn Differenz <= 0.3\n", + " \n", + " # Plot\n", + " plt.scatter(true_values[correct_indices], predicted_values[correct_indices], color='green', label='Richtig vorhergesagt')\n", + " plt.scatter(true_values[~correct_indices], predicted_values[~correct_indices], color='red', label='Falsch vorhergesagt')\n", + " plt.plot([min(true_values), max(true_values)], [min(true_values), max(true_values)], color='blue', linestyle='--', label='Ideal-Linie')\n", + " \n", + " plt.xlabel('Wahre Werte')\n", + " plt.ylabel('Vorhergesagte Werte')\n", + " plt.title('Richtige vs Falsche Vorhersagen')\n", + " plt.legend()\n", + " plt.grid(True)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot distribution of predicted values and true values\n", + "plt.figure(figsize=(10, 6))\n", + "plt.hist(test_labels, bins=20, color='skyblue', edgecolor='black', alpha=0.7, label='True Values')\n", + "plt.hist(test_preds, bins=20, color='salmon', edgecolor='black', alpha=0.7, label='Predicted Values')\n", + "plt.title('Distribution of Predicted and True Values')\n", + "plt.xlabel('Score')\n", + "plt.ylabel('Frequency')\n", + "plt.legend()\n", + "plt.grid(axis='y', linestyle='--', alpha=0.7)\n", "plt.show()" ] } diff --git a/cnn_reg_test.ipynb b/cnn_reg_test.ipynb deleted file mode 100644 index 5c4330d..0000000 --- a/cnn_reg_test.ipynb +++ /dev/null @@ -1,485 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# CNN Regression" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import time\n", - "import json\n", - "import math\n", - "\n", - "import torch\n", - "import torch.nn as nn\n", - "import torch.nn.functional as F\n", - "from torch.utils.data import DataLoader\n", - "from tqdm import tqdm # Fortschrittsbalken\n", - "from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score\n", - "\n", - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "\n", - "# local imports\n", - "import ml_evaluation as ml_eval\n", - "import ml_helper\n", - "import ml_history\n", - "import dataset_generator as data_gen\n", - "# class imports\n", - "import HumorDataset as humor_ds\n", - "import EarlyStopping\n", - "import BalancedCELoss\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "torch.manual_seed(0)\n", - "np.random.seed(0)\n", - "\n", - "\n", - "best_model_filename = 'best_cnn_reg_model.pt'\n", - "\n", - "device = ml_helper.get_device(verbose=True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "embedding_matrix, word_index, vocab_size, d_model = data_gen.create_embedding_matrix()\n", - "\n", - "vocab_size = len(embedding_matrix)\n", - "d_model = len(embedding_matrix[0])\n", - "vocab_size, d_model = embedding_matrix.size()\n", - "print(f\"vocab_size: {vocab_size}, d_model: {d_model}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "class CNN_HumorRegressor(nn.Module):\n", - " def __init__(self, embed_dim, filter_sizes, num_filters, dropout=0.5):\n", - " super(CNN_HumorRegressor, self).__init__()\n", - "\n", - " # Convolutional Layers mit verschiedenen Filtergrößen\n", - " self.convs = nn.ModuleList([\n", - " nn.Conv2d(in_channels=1, out_channels=num_filters, kernel_size=(fs, embed_dim)) \n", - " for fs in filter_sizes\n", - " ])\n", - "\n", - " # Highway-Netzwerk für bessere Feature-Extraktion\n", - " self.highway = nn.Linear(len(filter_sizes) * num_filters, len(filter_sizes) * num_filters)\n", - "\n", - " # Dropout zur Vermeidung von Overfitting\n", - " self.dropout = nn.Dropout(dropout)\n", - "\n", - " # Fully Connected Layers\n", - " self.fc1 = nn.Linear(len(filter_sizes) * num_filters, 256)\n", - " self.fc2 = nn.Linear(256, 128)\n", - " self.fc3 = nn.Linear(128, 1)\n", - "\n", - " def forward(self, x):\n", - " x = x.unsqueeze(1) # [Batch Size, 1, Seq Length, Embed Dim]\n", - "\n", - " # Convolution + ReLU activation\n", - " conved = [F.relu(conv(x)).squeeze(3) for conv in self.convs]\n", - "\n", - " # Max-Pooling über jede Feature-Map\n", - " pooled = [F.max_pool1d(c, c.size(2)).squeeze(2) for c in conved]\n", - "\n", - " # Feature-Vektor kombinieren\n", - " cat = torch.cat(pooled, dim=1)\n", - "\n", - " # Highway-Netzwerk\n", - " highway = F.relu(self.highway(cat))\n", - " highway = self.dropout(highway + cat)\n", - "\n", - " # Fully Connected Layers\n", - " fc_out = F.relu(self.fc1(highway))\n", - " fc_out = F.relu(self.fc2(fc_out))\n", - " return torch.sigmoid(self.fc3(fc_out)) # Sigmoid für Wertebereich [0, 1]\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "def load_preprocess_data(path_data='data/hack.csv'):\n", - " df = pd.read_csv(path_data)\n", - " df = df.dropna(subset=['humor_rating'])\n", - "\n", - " df['y'] = df['humor_rating']\n", - " X = df['text']\n", - " y = df['y']\n", - " return X, y" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "X,y = load_preprocess_data()\n", - "\n", - "ret_dict = data_gen.split_data(X, y)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "params = {\n", - " # used for class balancing\n", - " 'equalize_classes_loss_factor': 0.15, # 0.15 (0.1 to 0.2)\n", - " # training parameters\n", - " 'batch_size': 32, # 32 (16 to 64)\n", - " 'epochs': 10, # 100\n", - " 'lr': 1e-4, # 1e-5 (1e-6 to 1e-3)\n", - " \n", - " # CNN parameters\n", - " 'filter_sizes': [2, 3, 4],\n", - " 'num_filters': 150,\n", - " \n", - " # patience for early stopping\n", - " 'early_stopping_patience': 5, # 5 (3 to 10)\n", - "\n", - " # learning rate scheduler\n", - " 'lr_scheduler_factor': 0.5, # 0.1 (0.05 to 0.2)\n", - " 'lr_scheduler_patience': 3, # 3 (2 to 5)\n", - "\n", - " # model parameters\n", - " 'nhead': 2, # 5\n", - " 'num_layers': 3, # 6\n", - " 'hidden_dim': 10, # 50\n", - " \n", - "\n", - " # regularization parameters\n", - " 'positional_dropout': 0.5, # 0.1 (0.1 to 0.5)\n", - " 'classifier_dropout': 0.5, # 0.1 (0.1 to 0.5)\n", - " 'weight_decay': 1e-2 # 0.0 (1e-6 to 1e-2)\n", - "}\n", - "\n", - "# Model initialization\n", - "model = CNN_HumorRegressor(embed_dim=d_model, filter_sizes=params['filter_sizes'], num_filters=params['num_filters'], dropout=params['classifier_dropout'])\n", - "model.to(device)\n", - "print('model created')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# NOTE: Info comes from data explore notebook: 280 is max length,\n", - "# 139 contains 80% and 192 contains 95% of the data\n", - "max_len = 280\n", - "\n", - "train_dataset = humor_ds.TextDataset(ret_dict['train']['X'], ret_dict['train']['y'], word_index, max_len=max_len)\n", - "val_dataset = humor_ds.TextDataset(ret_dict['val']['X'], ret_dict['val']['y'], word_index, max_len=max_len)\n", - "test_dataset = humor_ds.TextDataset(ret_dict['test']['X'], ret_dict['test']['y'], word_index, max_len=max_len)\n", - "\n", - "print('datasets length:', len(train_dataset), len(val_dataset))\n", - "#NOTE: overfitting test\n", - "#train_dataset.labels = train_dataset.labels[:100]\n", - "#train_dataset.texts = train_dataset.texts[:100]\n", - "\n", - "train_loader = DataLoader(train_dataset, batch_size=params['batch_size'], shuffle=True)\n", - "val_loader = DataLoader(val_dataset, batch_size=params['batch_size'], shuffle=False)\n", - "test_loader = DataLoader(test_dataset, batch_size=params['batch_size'], shuffle=False)\n", - "\n", - "# NOTE: samller because of batches not all data\n", - "print(f\"train: {len(train_loader)}, val: {len(val_loader)}, test: {len(test_loader)}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#TODO: change to RMSE\n", - "\"\"\"\n", - "criterion = nn.MSELoss()\n", - "loss = torch.sqrt(criterion(x, y))\n", - "loss.backward()\n", - "print(x.grad)\n", - "\"\"\"\n", - "criterion = nn.MSELoss()\n", - "\n", - "optimizer = torch.optim.Adam((p for p in model.parameters() if p.requires_grad), \n", - " lr=params['lr']) #, \n", - " #weight_decay=params['weight_decay'])\n", - "\"\"\"\n", - "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', \n", - " factor=params['lr_scheduler_factor'],\n", - " patience=params['lr_scheduler_patience'],\n", - " verbose=True)\n", - "\"\"\"\n", - "early_stopping = EarlyStopping.EarlyStopping(patience=params['early_stopping_patience'], verbose=False)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# Training loop\n", - "\n", - "for epoch in range(params['epochs']):\n", - " epoch_start_time = time.time()\n", - " model.train()\n", - " \n", - " train_loss = 0.0\n", - " \n", - " for batch in train_loader:\n", - " optimizer.zero_grad()\n", - " input_ids, labels = batch\n", - " input_ids, labels = input_ids.to(device), labels.to(device).float() \n", - "\n", - " outputs = model(input_ids)\n", - " outputs = outputs.squeeze().float()\n", - " loss = criterion(outputs, labels)\n", - " loss.backward()\n", - " #torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=params['clipping_max_norm'])\n", - " optimizer.step()\n", - " preds = outputs\n", - " \n", - " train_loss += loss.item()\n", - "\n", - " train_loss /= len(train_loader)\n", - " \n", - " # Validation\n", - " model.eval()\n", - " val_loss = 0.0\n", - " \n", - " with torch.no_grad():\n", - " for batch in val_loader:\n", - " input_ids, labels = batch\n", - " input_ids, labels = input_ids.to(device), labels.to(device).float() \n", - " outputs = model(input_ids)\n", - " outputs = outputs.squeeze().float()\n", - " loss = criterion(outputs, labels)\n", - " preds = outputs\n", - " \n", - " val_loss += loss.item()\n", - "\n", - " val_loss /= len(val_loader)\n", - " \n", - " epoch_end_time = time.time()\n", - " \n", - " print(f'Epoch {epoch+1}/{params[\"epochs\"]}, '\n", - " f'Train Loss: {train_loss:.4f}, '\n", - " f'Val Loss: {val_loss:.4f}, '\n", - " f'Time: {epoch_end_time - epoch_start_time:.2f}s')\n", - "\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Evaluation Metrics on Test Data:\n", - "Mean Squared Error (MSE): 0.3358\n", - "Root Mean Squared Error (RMSE): 0.5795\n", - "Mean Absolute Error (MAE): 0.3900\n", - "R² Score: -0.3445\n" - ] - } - ], - "source": [ - "# TODO: Evaluate model\n", - "'''\n", - "def evaluate_metrics(model, test_loader, device):\n", - " model.eval()\n", - " predictions = []\n", - " actuals = []\n", - " with torch.no_grad():\n", - " for inputs, labels in test_loader:\n", - " inputs, labels = inputs.to(device), labels.to(device)\n", - " outputs = model(inputs)\n", - " predictions.extend(outputs.cpu().numpy().flatten())\n", - " actuals.extend(labels.cpu().numpy().flatten())\n", - "\n", - " mse = mean_squared_error(actuals, predictions)\n", - " rmse = np.sqrt(mse)\n", - " mae = mean_absolute_error(actuals, predictions)\n", - " r2 = r2_score(actuals, predictions)\n", - "\n", - " return mse, rmse, mae, r2, actuals, predictions\n", - "\n", - "mse, rmse, mae, r2, actuals, predictions = evaluate_metrics(model, test_loader, device)\n", - "\n", - "print(\"Evaluation Metrics on Test Data:\")\n", - "print(f\"Mean Squared Error (MSE): {mse:.4f}\")\n", - "print(f\"Root Mean Squared Error (RMSE): {rmse:.4f}\")\n", - "print(f\"Mean Absolute Error (MAE): {mae:.4f}\")\n", - "print(f\"R² Score: {r2:.4f}\")\n", - "\n", - "'''" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#TODO: Plotting\n", - "'''\n", - "# Definiere korrekte und falsche Vorhersagen basierend auf einem Schwellenwert\n", - "threshold = 0.5\n", - "predicted_labels = (np.array(predictions) > threshold).astype(int)\n", - "true_labels = (np.array(actuals) > threshold).astype(int)\n", - "\n", - "# Bool-Array für korrekte Vorhersagen\n", - "correct = predicted_labels == true_labels\n", - "\n", - "# Farben zuordnen: Grün für korrekt, Rot für falsch\n", - "colors = ['green' if is_correct else 'red' for is_correct in correct]\n", - "\n", - "# Scatter-Plot\n", - "plt.figure(figsize=(8, 6))\n", - "plt.scatter(actuals, predictions, c=colors, alpha=0.6, edgecolor='k')\n", - "\n", - "\n", - "# Legende anpassen\n", - "import matplotlib.patches as mpatches\n", - "green_patch = mpatches.Patch(color='green', label='Correct Predictions')\n", - "red_patch = mpatches.Patch(color='red', label='Incorrect Predictions')\n", - "plt.legend(handles=[green_patch, red_patch])\n", - "\n", - "# Achsen und Titel\n", - "plt.title('True vs. Predicted Humor Scores')\n", - "plt.xlabel('True Humor Score')\n", - "plt.ylabel('Predicted Humor Score')\n", - "plt.show()\n", - "'''\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "239\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "'''\n", - "#TODO: Plotting\n", - "import pandas as pd\n", - "\n", - "# Load the data from csv\n", - "df = pd.read_csv('data/hack.csv')\n", - "df_test = df.iloc[test_dataset.original_indices].copy()\n", - "df_test['prediction'] = predicted_labels\n", - "df_test['label'] = true_labels\n", - "df_test['pred_correct'] = (df_test['prediction'] == df_test['label'])\n", - "\n", - "df_test_sorted = df_test.sort_values(by='humor_rating').reset_index(drop=True)\n", - "\n", - "from matplotlib import patches as mpatches\n", - "\n", - "median_rating = df['humor_rating'].median()\n", - "# get first index where humor_rating is greater than median_rating\n", - "median_idx = df_test_sorted[df_test_sorted['humor_rating'] > median_rating].index[0]\n", - "print(median_idx)\n", - "# range idx for len df_test\n", - "range_idx = range(len(df_test))\n", - "colors = df_test_sorted['pred_correct'].map({True: 'g', False: 'r'})\n", - "# bar plot for each df_test humor_rating value \n", - "plt.bar(range_idx, df_test_sorted['humor_rating'], color=colors)\n", - "# vertical line for True/False cut off\n", - "plt.axvline(x=median_idx, color='black', linestyle='--')\n", - "# Create a legend handles\n", - "green_patch = mpatches.Patch(color='g', label='Correct Prediction')\n", - "red_patch = mpatches.Patch(color='r', label='Incorrect Prediction')\n", - "line_patch = mpatches.Patch(color='black', label='humor_rating cut off')\n", - "plt.title('Humor Rating vs Prediction for Test Set')\n", - "plt.xlabel('Index')\n", - "plt.ylabel('Humor Rating')\n", - "plt.legend(handles=[green_patch, red_patch, line_patch])\n", - "plt.show()\n", - "''''''" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/test_cnn.py b/test_cnn.py deleted file mode 100644 index 0309d42..0000000 --- a/test_cnn.py +++ /dev/null @@ -1,186 +0,0 @@ -import pandas as pd -import numpy as np -import torch -import torch.nn as nn -from torch.utils.data import DataLoader, Dataset -from sklearn.model_selection import train_test_split -from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score -import matplotlib.pyplot as plt -import matplotlib.patches as mpatches -from tqdm import tqdm -from dataset_generator import create_embedding_matrix -from EarlyStopping import EarlyStopping - -# 1. Gerät automatisch erkennen (MPS, CUDA oder CPU) -device = torch.device('mps' if torch.backends.mps.is_available() - else 'cuda' if torch.cuda.is_available() - else 'cpu') -print(f"Using device: {device}") - -# 2. Daten laden -data = pd.read_csv('data/hack.csv') - -# 3. Filtern humorvoller Texte -humor_data = data[data['is_humor'] == 1].dropna(subset=['humor_rating']).copy() - -# 4. Einbettungsmatrix erstellen -embedding_matrix, word_index, vocab_size, d_model = create_embedding_matrix( - gloVe_path='data/glove.6B.100d.txt', emb_len=100 -) -print(f"vocab_size: {vocab_size}, d_model: {d_model}") - -# 5. Tokenisierung und Padding mit PyTorch -def tokenize_and_pad(texts, word_index, max_len=50): - sequences = [] - for text in texts: - tokens = [word_index.get(word, 0) for word in text.split()] - if len(tokens) < max_len: - tokens += [0] * (max_len - len(tokens)) - else: - tokens = tokens[:max_len] - sequences.append(tokens) - return torch.tensor(sequences, dtype=torch.long) - -# Training und Testdaten splitten -train_texts, test_texts, train_labels, test_labels = train_test_split( - humor_data['text'], humor_data['humor_rating'], test_size=0.2, random_state=42 -) - -# Tokenisierung und Padding -max_len = 50 -train_input_ids = tokenize_and_pad(train_texts, word_index, max_len=max_len) -test_input_ids = tokenize_and_pad(test_texts, word_index, max_len=max_len) - -# Labels in Tensor konvertieren -train_labels = torch.tensor(train_labels.values, dtype=torch.float) -test_labels = torch.tensor(test_labels.values, dtype=torch.float) - -# 6. Dataset-Klasse für PyTorch -class HumorDataset(Dataset): - def __init__(self, input_ids, labels): - self.input_ids = input_ids - self.labels = labels - - def __len__(self): - return len(self.input_ids) - - def __getitem__(self, idx): - return self.input_ids[idx], self.labels[idx] - -# Dataset und DataLoader erstellen -train_dataset = HumorDataset(train_input_ids, train_labels) -test_dataset = HumorDataset(test_input_ids, test_labels) - -train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True) -test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False) - -# 7. CNN-Regression-Modell definieren -class CNNRegressor(nn.Module): - def __init__(self, vocab_size, embed_dim, embedding_matrix): - super(CNNRegressor, self).__init__() - self.embedding = nn.Embedding(vocab_size, embed_dim) - self.embedding.weight.data.copy_(embedding_matrix.clone().detach()) - self.embedding.weight.requires_grad = False - self.conv1 = nn.Conv1d(embed_dim, 128, kernel_size=3) - self.conv2 = nn.Conv1d(128, 64, kernel_size=3) - self.dropout = nn.Dropout(0.5) - self.fc = nn.Linear(64, 1) - - def forward(self, x): - x = self.embedding(x).permute(0, 2, 1) - x = torch.relu(self.conv1(x)) - x = torch.relu(self.conv2(x)) - x = self.dropout(x) - x = torch.max(x, dim=2).values - x = self.fc(x) - x = torch.sigmoid(x) * 5 # Wertebereich [0, 5] - return x - -# Initialisiere das Modell -model = CNNRegressor(vocab_size, d_model, embedding_matrix).to(device) -criterion = nn.MSELoss() -optimizer = torch.optim.Adam(model.parameters(), lr=0.001) - -# Early Stopping -#early_stopping = EarlyStopping(patience=5) - -# 8. Training mit Validierung -for epoch in range(20): # Maximal 20 Epochen - model.train() - train_loss = 0 - for inputs, labels in tqdm(train_loader, desc=f"Epoch {epoch+1}"): - inputs, labels = inputs.to(device), labels.to(device) - optimizer.zero_grad() - outputs = model(inputs).squeeze() - loss = criterion(outputs, labels) - loss.backward() - optimizer.step() - train_loss += loss.item() - - train_loss /= len(train_loader) - - # Validierungsverlust berechnen - model.eval() - val_loss = 0 - with torch.no_grad(): - for inputs, labels in test_loader: - inputs, labels = inputs.to(device), labels.to(device) - outputs = model(inputs).squeeze() - loss = criterion(outputs, labels) - val_loss += loss.item() - val_loss /= len(test_loader) - - print(f"Epoch {epoch+1}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}") - - # Early Stopping - '''early_stopping(val_loss, model) - if early_stopping.early_stop: - print("Early stopping triggered") - break''' - -# 9. Modell evaluieren -def evaluate_model(model, data_loader): - model.eval() - predictions = [] - actuals = [] - with torch.no_grad(): - for inputs, labels in data_loader: - inputs, labels = inputs.to(device), labels.to(device) - outputs = model(inputs).squeeze() - predictions.extend(outputs.cpu().numpy()) - actuals.extend(labels.cpu().numpy()) - return predictions, actuals - -predictions, actuals = evaluate_model(model, test_loader) - -# Metriken berechnen -mse = mean_squared_error(actuals, predictions) -mae = mean_absolute_error(actuals, predictions) -r2 = r2_score(actuals, predictions) - -print(f"MSE: {mse:.4f}, MAE: {mae:.4f}, R²: {r2:.4f}") - -# 10. Visualisierung (Korrekte und falsche Vorhersagen farblich darstellen) -tolerance = 0.5 # Toleranz für korrekte Vorhersagen -predictions = np.array(predictions) -actuals = np.array(actuals) - -# Klassifikation: Grün (korrekt), Rot (falsch) -correct = np.abs(predictions - actuals) <= tolerance -colors = np.where(correct, 'green', 'red') - -# Scatter-Plot -plt.figure(figsize=(8, 6)) -plt.scatter(actuals, predictions, c=colors, alpha=0.6, edgecolor='k', s=50) -plt.plot([0, 5], [0, 5], color='red', linestyle='--') # Perfekte Vorhersage-Linie - -# Legende -green_patch = mpatches.Patch(color='green', label='Correct Predictions') -red_patch = mpatches.Patch(color='red', label='Incorrect Predictions') -plt.legend(handles=[green_patch, red_patch]) - -# Achsen und Titel -plt.xlabel("True Humor Ratings") -plt.ylabel("Predicted Humor Ratings") -plt.title("True vs Predicted Humor Ratings (Correct vs Incorrect)") -plt.show() From 7500367475ee41679478034349d20dd4b72c6ad2 Mon Sep 17 00:00:00 2001 From: arman Date: Sat, 15 Feb 2025 14:23:10 +0100 Subject: [PATCH 4/4] lines dashed --- transformer_bootstrap_agg.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/transformer_bootstrap_agg.py b/transformer_bootstrap_agg.py index 3d35d1d..5cfb764 100644 --- a/transformer_bootstrap_agg.py +++ b/transformer_bootstrap_agg.py @@ -282,7 +282,7 @@ fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6)) # Plot Train and Validation Losses for i in range(num_models): ax1.plot(range(1, params['epochs'] + 1), all_train_losses[i], label=f"Train Model {i+1}") - ax1.plot(range(1, params['epochs'] + 1), all_val_losses[i], label=f"Val Model {i+1}") + ax1.plot(range(1, params['epochs'] + 1), all_val_losses[i], label=f"Val Model {i+1}", linestyle='dashed') ax1.set_title('Train and Validation Loss') ax1.set_xlabel('Epochs') @@ -292,7 +292,7 @@ ax1.legend() # Plot Train and Validation R² for i in range(num_models): ax2.plot(range(1, params['epochs'] + 1), all_train_r2_scores[i], label=f"Train Model {i+1}") - ax2.plot(range(1, params['epochs'] + 1), all_val_r2_scores[i], label=f"Val Model {i+1}") + ax2.plot(range(1, params['epochs'] + 1), all_val_r2_scores[i], label=f"Val Model {i+1}", linestyle='dashed') ax2.set_title('Train and Validation R²') ax2.set_xlabel('Epochs')