diff --git a/.gitignore b/.gitignore index bf9a08a..d8050bb 100644 --- a/.gitignore +++ b/.gitignore @@ -23,4 +23,8 @@ plots/ *.jpg # Ignore everything with delete_me in name -*delete_me* \ No newline at end of file +*delete_me* + +# Ignore glove +*.zip +*glove*/ \ No newline at end of file diff --git a/README.md b/README.md index c993e91..9a6744d 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,8 @@ https://aclanthology.org/2021.semeval-1.9.pdf#:~:text=HaHackathon%20is%20the%20f +## Data embeddings +- gloVe 6B tokens: https://nlp.stanford.edu/projects/glove/ diff --git a/data/embedded_padded/test.pt b/data/embedded_padded/test.pt index c806369..eebf938 100644 Binary files a/data/embedded_padded/test.pt and b/data/embedded_padded/test.pt differ diff --git a/data/embedded_padded/train.pt b/data/embedded_padded/train.pt index 0a04318..e50ea20 100644 Binary files a/data/embedded_padded/train.pt and b/data/embedded_padded/train.pt differ diff --git a/data/embedded_padded/val.pt b/data/embedded_padded/val.pt index 2da4843..8a46d1e 100644 Binary files a/data/embedded_padded/val.pt and b/data/embedded_padded/val.pt differ diff --git a/dataset_generator.py b/dataset_generator.py index a0f7118..35ae04e 100644 --- a/dataset_generator.py +++ b/dataset_generator.py @@ -8,6 +8,7 @@ from nltk.tokenize import word_tokenize import gensim import torch import os +import copy from HumorDataset import HumorDataset @@ -23,6 +24,27 @@ def get_embedding_vector(model, word): else: return np.zeros(model.vector_size) +def load_glove_embeddings(glove_file_path): + embeddings_index = {} + with open(glove_file_path, 'r', encoding='utf-8') as f: + for line in f: + values = line.split() + word = values[0] + coefs = np.asarray(values[1:], dtype='float32') + embeddings_index[word] = coefs + return embeddings_index + +def get_embedding_glove_vector(tokens, embeddings_index, default_vector_len=100, pad_tok=''): + default_vec = [0] * default_vector_len + emb_matrix = [] + for token in tokens: + if token == pad_tok: + embedding_vector = default_vec + else: + embedding_vector = embeddings_index.get(token, default_vec) + emb_matrix.append(embedding_vector) + return emb_matrix + def encode_tokens(tokens, vector=False): if vector: return [get_embedding_vector(model_embedding, token) for token in tokens] @@ -87,8 +109,7 @@ if __name__ == "__main__": # split data into train, test, and validation data_dict = split_data(padded_indices, y) - - # TODO: test gloVe embeddings + # Embed the data with word2vec model_embedding = gensim.models.Word2Vec(tokens, window=5, min_count=1, workers=4) @@ -101,7 +122,7 @@ if __name__ == "__main__": pad_index = model_embedding.wv.key_to_index[''] - data_idx_based = data_dict.copy() + data_idx_based = copy.deepcopy(data_dict) vector_based = False for key in data_idx_based.keys(): @@ -112,10 +133,15 @@ if __name__ == "__main__": # save the data save_data(data_idx_based, 'data/idx_based_padded/', '', vocab_size) + print('loading GloVe embeddings') vector_based = True + # Load GloVe embeddings + glove_file_path = 'glove.6B/glove.6B.100d.txt' + embeddings_index = load_glove_embeddings(glove_file_path) + print('starting with embedding the data') # Encode the tokens for key in data_dict.keys(): - data_dict[key]['X'] = [encode_tokens(tokens, vector_based) for tokens in data_dict[key]['X']] + data_dict[key]['X'] = [get_embedding_glove_vector(tokens, embeddings_index) for tokens in data_dict[key]['X']] # print shape of data #print(key, len(data_dict[key]['X']), len(data_dict[key]['y'])) diff --git a/transformer_evaluation.ipynb b/transformer_evaluation.ipynb index 412f20e..a36a2e1 100644 --- a/transformer_evaluation.ipynb +++ b/transformer_evaluation.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 93, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -25,25 +25,31 @@ }, { "cell_type": "code", - "execution_count": 94, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Loading model from: models/transformer_acc_0.5056_20250127-061459.pth\n", - "Loading history from: models/transformer_history_20250127-061459.json\n", - "Loading hyperparameters from: models/transformer_para_acc_0.5056_20250127-061459.json\n" + "Loading model from: models/transformer_acc_0.5056_20250127-061459.pth\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\felix\\AppData\\Local\\Temp\\ipykernel_16796\\1644685603.py:5: 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", + "C:\\Users\\felix\\AppData\\Local\\Temp\\ipykernel_5648\\1644685603.py:5: 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 = torch.load(model_path)\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading history from: models/transformer_history_20250127-061459.json\n", + "Loading hyperparameters from: models/transformer_para_acc_0.5056_20250127-061459.json\n" + ] } ], "source": [ @@ -68,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 95, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -104,7 +110,7 @@ }, { "cell_type": "code", - "execution_count": 130, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -135,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 97, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -156,18 +162,18 @@ }, { "cell_type": "code", - "execution_count": 98, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\felix\\AppData\\Local\\Temp\\ipykernel_16796\\4202493223.py:4: 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", + "C:\\Users\\felix\\AppData\\Local\\Temp\\ipykernel_5648\\4202493223.py:4: 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", - "C:\\Users\\felix\\AppData\\Local\\Temp\\ipykernel_16796\\4202493223.py:5: 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", + "C:\\Users\\felix\\AppData\\Local\\Temp\\ipykernel_5648\\4202493223.py:5: 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", - "C:\\Users\\felix\\AppData\\Local\\Temp\\ipykernel_16796\\4202493223.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", + "C:\\Users\\felix\\AppData\\Local\\Temp\\ipykernel_5648\\4202493223.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", " val_dataset = torch.load(data_path + '/val.pt')\n" ] } @@ -183,7 +189,52 @@ }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{False: 2001, True: 1944}\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# count train_dataset labels\n", + "train_labels = train_dataset.labels\n", + "unique, counts = np.unique(train_labels, return_counts=True)\n", + "print(dict(zip(unique, counts)))\n", + "\n", + "idx_range = range(0, len(train_dataset))\n", + "# plot label distribution\n", + "plt.bar(idx_range, train_labels)\n", + "plt.title('Label distribution')\n", + "plt.xlabel('Index')\n", + "plt.ylabel('Label')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- If distribution wouldnt be random it could screw up the training process" + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -200,7 +251,7 @@ }, { "cell_type": "code", - "execution_count": 100, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -217,7 +268,7 @@ }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -226,7 +277,7 @@ "text": [ "c:\\Users\\felix\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\torch\\nn\\modules\\transformer.py:379: UserWarning: enable_nested_tensor is True, but self.use_nested_tensor is False because encoder_layer.self_attn.batch_first was not True(use batch_first for better inference performance)\n", " warnings.warn(\n", - "C:\\Users\\felix\\AppData\\Local\\Temp\\ipykernel_16796\\3082896325.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", + "C:\\Users\\felix\\AppData\\Local\\Temp\\ipykernel_5648\\3082896325.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", " model.load_state_dict(torch.load(model_path))\n" ] } @@ -268,7 +319,7 @@ }, { "cell_type": "code", - "execution_count": 113, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -283,7 +334,7 @@ }, { "cell_type": "code", - "execution_count": 128, + "execution_count": 11, "metadata": {}, "outputs": [ {