diff --git "a/final_dev.ipynb" "b/final_dev.ipynb"
new file mode 100644--- /dev/null
+++ "b/final_dev.ipynb"
@@ -0,0 +1,1834 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "8DF-QiZIlCau"
+ },
+ "source": [
+ "# Import libraries"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {
+ "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
+ "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:57:18.884233Z",
+ "iopub.status.busy": "2023-05-20T09:57:18.883438Z",
+ "iopub.status.idle": "2023-05-20T09:57:27.009157Z",
+ "shell.execute_reply": "2023-05-20T09:57:27.008085Z",
+ "shell.execute_reply.started": "2023-05-20T09:57:18.884079Z"
+ },
+ "id": "xSsSrswIlCbJ",
+ "trusted": true
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import pandas as pd \n",
+ "import tensorflow as tf\n",
+ "import nltk\n",
+ "import seaborn as sns\n",
+ "import re\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "from tensorflow.keras.layers import Embedding, Dense, LSTM, Dropout, Bidirectional\n",
+ "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
+ "from tensorflow.keras.models import Sequential\n",
+ "from tensorflow.keras.preprocessing.text import one_hot, Tokenizer\n",
+ "from tensorflow.keras.callbacks import ModelCheckpoint\n",
+ "from nltk.corpus import stopwords\n",
+ "from nltk.stem.porter import PorterStemmer\n",
+ "from sklearn import preprocessing\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 45,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "Od8s_dawlvmX",
+ "outputId": "b7469730-880e-4801-b80b-26ddf4086962"
+ },
+ "outputs": [],
+ "source": [
+ "# from google.colab import drive\n",
+ "# drive.mount('/content/drive')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "GToU1HyYlCbO"
+ },
+ "source": [
+ "# Read and clean data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 206
+ },
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:57:27.011197Z",
+ "iopub.status.busy": "2023-05-20T09:57:27.010830Z",
+ "iopub.status.idle": "2023-05-20T09:57:27.124001Z",
+ "shell.execute_reply": "2023-05-20T09:57:27.122911Z",
+ "shell.execute_reply.started": "2023-05-20T09:57:27.011157Z"
+ },
+ "id": "3dx_SWZ9lCbR",
+ "outputId": "34dbeca7-4f75-407f-ad15-bfb1d0c00e7f",
+ "trusted": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " Text | \n",
+ " Emotion | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 | \n",
+ " i didnt feel humiliated | \n",
+ " sadness | \n",
+ "
\n",
+ " \n",
+ " 1 | \n",
+ " i can go from feeling so hopeless to so damned... | \n",
+ " sadness | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " im grabbing a minute to post i feel greedy wrong | \n",
+ " anger | \n",
+ "
\n",
+ " \n",
+ " 3 | \n",
+ " i am ever feeling nostalgic about the fireplac... | \n",
+ " love | \n",
+ "
\n",
+ " \n",
+ " 4 | \n",
+ " i am feeling grouchy | \n",
+ " anger | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " Text Emotion\n",
+ "0 i didnt feel humiliated sadness\n",
+ "1 i can go from feeling so hopeless to so damned... sadness\n",
+ "2 im grabbing a minute to post i feel greedy wrong anger\n",
+ "3 i am ever feeling nostalgic about the fireplac... love\n",
+ "4 i am feeling grouchy anger"
+ ]
+ },
+ "execution_count": 46,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df=pd.read_csv('Emotion_final.csv') #Text data\n",
+ "EMBEDDING_FILE= f'glove.6B.100d.txt' #GloVe file path\n",
+ "df.head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 47,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "ZZErgiR4FL5R",
+ "outputId": "dc25d93e-c695-43d0-f8cc-0933b9d4bf89"
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(21459, 2)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(df.shape)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "00foXnmyFUub",
+ "outputId": "04aa0bb4-113c-4652-9a9d-12e98291cc58"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "happy 7029\n",
+ "sadness 6265\n",
+ "anger 2993\n",
+ "fear 2652\n",
+ "love 1641\n",
+ "surprise 879\n",
+ "Name: Emotion, dtype: int64"
+ ]
+ },
+ "execution_count": 48,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df.Emotion.value_counts()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "qyC1SMm0FdNI",
+ "outputId": "73b83d1d-a318-4e82-9f19-3a9705d87da8"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "happy 32.755487\n",
+ "sadness 29.195209\n",
+ "anger 13.947528\n",
+ "fear 12.358451\n",
+ "love 7.647141\n",
+ "surprise 4.096183\n",
+ "Name: Emotion, dtype: float64"
+ ]
+ },
+ "execution_count": 49,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "#check if the data is balanced or not\n",
+ "df.Emotion.value_counts() / df.shape[0] *100"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 534
+ },
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:57:27.127037Z",
+ "iopub.status.busy": "2023-05-20T09:57:27.126495Z",
+ "iopub.status.idle": "2023-05-20T09:57:27.370980Z",
+ "shell.execute_reply": "2023-05-20T09:57:27.369897Z",
+ "shell.execute_reply.started": "2023-05-20T09:57:27.126984Z"
+ },
+ "id": "rq5cQgJHlCbV",
+ "outputId": "a262633a-c38e-4755-8ca7-5fcc122318f8",
+ "trusted": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "#Target Classes\n",
+ "plt.figure(figsize=(18,8))\n",
+ "sns.countplot(x='Emotion', data=df); "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "wF49V8r8FxIj",
+ "outputId": "c5205d06-bba7-4e49-96fc-384a12fe52d9"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "3"
+ ]
+ },
+ "execution_count": 51,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "#print the number of duplicated values \n",
+ "df.duplicated().sum()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "metadata": {
+ "id": "OlWasVH6F5rV"
+ },
+ "outputs": [],
+ "source": [
+ "#removing duplicated values\n",
+ "index = df[df.duplicated() == True].index\n",
+ "df.drop(index, axis = 0, inplace = True)\n",
+ "df.reset_index(inplace=True, drop = True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 424
+ },
+ "id": "azV1NWQ8GCQ6",
+ "outputId": "7bbd904f-9175-4680-d9d9-598128f3a3b5"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " Text | \n",
+ " Emotion | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " 11898 | \n",
+ " i am feeling stressed and more than a bit anxious | \n",
+ " sadness | \n",
+ "
\n",
+ " \n",
+ " 16501 | \n",
+ " i am feeling stressed and more than a bit anxious | \n",
+ " anger | \n",
+ "
\n",
+ " \n",
+ " 8246 | \n",
+ " i am not amazing or great at photography but i... | \n",
+ " love | \n",
+ "
\n",
+ " \n",
+ " 3508 | \n",
+ " i am not amazing or great at photography but i... | \n",
+ " happy | \n",
+ "
\n",
+ " \n",
+ " 15704 | \n",
+ " i began to feel accepted by gaia on her own terms | \n",
+ " happy | \n",
+ "
\n",
+ " \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ "
\n",
+ " \n",
+ " 11354 | \n",
+ " i write these words i feel sweet baby kicks fr... | \n",
+ " love | \n",
+ "
\n",
+ " \n",
+ " 7685 | \n",
+ " im still not sure why reilly feels the need to... | \n",
+ " surprise | \n",
+ "
\n",
+ " \n",
+ " 2908 | \n",
+ " im still not sure why reilly feels the need to... | \n",
+ " fear | \n",
+ "
\n",
+ " \n",
+ " 9069 | \n",
+ " ive also made it with both sugar measurements ... | \n",
+ " love | \n",
+ "
\n",
+ " \n",
+ " 9596 | \n",
+ " ive also made it with both sugar measurements ... | \n",
+ " happy | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
102 rows × 2 columns
\n",
+ "
"
+ ],
+ "text/plain": [
+ " Text Emotion\n",
+ "11898 i am feeling stressed and more than a bit anxious sadness\n",
+ "16501 i am feeling stressed and more than a bit anxious anger\n",
+ "8246 i am not amazing or great at photography but i... love\n",
+ "3508 i am not amazing or great at photography but i... happy\n",
+ "15704 i began to feel accepted by gaia on her own terms happy\n",
+ "... ... ...\n",
+ "11354 i write these words i feel sweet baby kicks fr... love\n",
+ "7685 im still not sure why reilly feels the need to... surprise\n",
+ "2908 im still not sure why reilly feels the need to... fear\n",
+ "9069 ive also made it with both sugar measurements ... love\n",
+ "9596 ive also made it with both sugar measurements ... happy\n",
+ "\n",
+ "[102 rows x 2 columns]"
+ ]
+ },
+ "execution_count": 53,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "#print the rows which are duplicated (duplicated in the text but with different emotions)\n",
+ "duplicated_rows = df[df['Text'].duplicated(keep=False)].sort_values('Text')\n",
+ "duplicated_rows"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {
+ "id": "gfUJhZzOHXC4"
+ },
+ "outputs": [],
+ "source": [
+ "#removing duplicated text \n",
+ "index = df[df['Text'].duplicated() == True].index\n",
+ "df.drop(index, axis = 0, inplace = True)\n",
+ "df.reset_index(inplace=True, drop = True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:57:27.373030Z",
+ "iopub.status.busy": "2023-05-20T09:57:27.372682Z",
+ "iopub.status.idle": "2023-05-20T09:57:27.404494Z",
+ "shell.execute_reply": "2023-05-20T09:57:27.403478Z",
+ "shell.execute_reply.started": "2023-05-20T09:57:27.372996Z"
+ },
+ "id": "lJHgJOYxlCbX",
+ "trusted": true
+ },
+ "outputs": [],
+ "source": [
+ "df=df.dropna() #Drop columns with NA values\n",
+ "X=df.drop('Emotion',axis=1) #Taking Text\n",
+ "y=df['Emotion'] #Taking Emotion"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "id": "vLKe-NmBLDpT",
+ "outputId": "f2141125-9a90-403d-cf8c-ef6584447870"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((21405, 1), (21405,))"
+ ]
+ },
+ "execution_count": 56,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "X.shape, y.shape"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:57:27.406360Z",
+ "iopub.status.busy": "2023-05-20T09:57:27.405986Z",
+ "iopub.status.idle": "2023-05-20T09:57:27.414793Z",
+ "shell.execute_reply": "2023-05-20T09:57:27.413772Z",
+ "shell.execute_reply.started": "2023-05-20T09:57:27.406321Z"
+ },
+ "id": "rVmnGk5hlCba",
+ "trusted": true
+ },
+ "outputs": [],
+ "source": [
+ "messages=X.copy()\n",
+ "messages.reset_index(inplace=True) #Drop NA may cause inconsistency in index"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:57:27.417777Z",
+ "iopub.status.busy": "2023-05-20T09:57:27.416163Z",
+ "iopub.status.idle": "2023-05-20T09:59:04.122080Z",
+ "shell.execute_reply": "2023-05-20T09:59:04.120911Z",
+ "shell.execute_reply.started": "2023-05-20T09:57:27.417726Z"
+ },
+ "id": "TpU1I9lelCbc",
+ "outputId": "443bbff3-4ee6-4446-8eae-4495b8f4aed9",
+ "trusted": true
+ },
+ "outputs": [],
+ "source": [
+ "import pickle\n",
+ "stopwords_path = 'stopwords.pkl'\n",
+ "with open(stopwords_path, 'rb') as file:\n",
+ " stopwords_list = pickle.load(file)\n",
+ " \n",
+ "ps = PorterStemmer() # reduce word to root form\n",
+ "corpus = []\n",
+ "for i in range(0, len(messages)):\n",
+ " review = re.sub('[^a-zA-Z]', ' ', messages['Text'][i]) #Remove Special Characters\n",
+ " review = review.lower() #Lower case \n",
+ " review = review.split()\n",
+ " review = [ps.stem(word) for word in review if not word in stopwords_list] #Remove stopwords\n",
+ " review = ' '.join(review)\n",
+ " corpus.append(review)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:59:04.124093Z",
+ "iopub.status.busy": "2023-05-20T09:59:04.123642Z",
+ "iopub.status.idle": "2023-05-20T09:59:04.131751Z",
+ "shell.execute_reply": "2023-05-20T09:59:04.130518Z",
+ "shell.execute_reply.started": "2023-05-20T09:59:04.124047Z"
+ },
+ "id": "vXmZVFyHlCbg",
+ "outputId": "8d82e3c3-9e39-4fd2-ab74-1882f1f98c5f",
+ "trusted": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['didnt feel humili',\n",
+ " 'go feel hopeless damn hope around someon care awak',\n",
+ " 'im grab minut post feel greedi wrong',\n",
+ " 'ever feel nostalg fireplac know still properti',\n",
+ " 'feel grouchi',\n",
+ " 'ive feel littl burden late wasnt sure',\n",
+ " 'ive take milligram time recommend amount ive fallen asleep lot faster also feel like funni',\n",
+ " 'feel confus life teenag jade year old man',\n",
+ " 'petrona year feel petrona perform well made huge profit',\n",
+ " 'feel romant']"
+ ]
+ },
+ "execution_count": 59,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "corpus[:10]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "lyimoS4ilCbm"
+ },
+ "source": [
+ "# Embedding layer using GloVe "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:59:04.135091Z",
+ "iopub.status.busy": "2023-05-20T09:59:04.134761Z",
+ "iopub.status.idle": "2023-05-20T09:59:25.514299Z",
+ "shell.execute_reply": "2023-05-20T09:59:25.513098Z",
+ "shell.execute_reply.started": "2023-05-20T09:59:04.135057Z"
+ },
+ "id": "WqjbyO6slCbo",
+ "outputId": "5f271b05-fec6-4eb9-a5ef-16638a3329d3",
+ "trusted": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/home/devraj4522/anaconda3/envs/carefi/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3400: FutureWarning: arrays to stack must be passed as a \"sequence\" type such as list or tuple. Support for non-sequence iterables such as generators is deprecated as of NumPy 1.16 and will raise an error in the future.\n",
+ " if await self.run_code(code, result, async_=asy):\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0.004451992 0.4081574\n"
+ ]
+ }
+ ],
+ "source": [
+ "#Creating the dictionary with word as key and pretrained-value array as value\n",
+ "def get_coefs(word,*arr): return word, np.asarray(arr, dtype='float32')\n",
+ "embeddings_index = dict(get_coefs(*o.strip().split()) for o in open(EMBEDDING_FILE))\n",
+ "# print(embeddings_index)\n",
+ "#Calculate mean and std for the pretrained weights\n",
+ "all_embs = np.stack(embeddings_index.values())\n",
+ "emb_mean,emb_std = all_embs.mean(), all_embs.std()\n",
+ "print(emb_mean,emb_std)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:59:25.517431Z",
+ "iopub.status.busy": "2023-05-20T09:59:25.516759Z",
+ "iopub.status.idle": "2023-05-20T09:59:26.027236Z",
+ "shell.execute_reply": "2023-05-20T09:59:26.025696Z",
+ "shell.execute_reply.started": "2023-05-20T09:59:25.517378Z"
+ },
+ "id": "a6ODTAztlCbs",
+ "trusted": true
+ },
+ "outputs": [],
+ "source": [
+ "voc_size=10000 # Vocabulary size\n",
+ "embed_size=100 #word vector size\n",
+ "\n",
+ "tokenizer = Tokenizer(num_words=voc_size)\n",
+ "tokenizer.fit_on_texts(list(corpus))\n",
+ "word_index = tokenizer.word_index #Total words in the corpus\n",
+ "nb_words = min(voc_size, len(word_index))\n",
+ "\n",
+ "#Initialize weight matrix for embedding layer\n",
+ "embedding_matrix = np.random.normal(emb_mean, emb_std, (nb_words, embed_size)) \n",
+ "\n",
+ "for word, i in word_index.items():\n",
+ " if i >= voc_size: continue #Skip the words if vocab size is reached\n",
+ " embedding_vector = embeddings_index.get(word) #Extract the pretrained values from GloVe\n",
+ " if embedding_vector is not None: embedding_matrix[i] = embedding_vector"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:59:26.029249Z",
+ "iopub.status.busy": "2023-05-20T09:59:26.028844Z",
+ "iopub.status.idle": "2023-05-20T09:59:26.035050Z",
+ "shell.execute_reply": "2023-05-20T09:59:26.034145Z",
+ "shell.execute_reply.started": "2023-05-20T09:59:26.029207Z"
+ },
+ "id": "1o0AhuUglCbu",
+ "outputId": "94715f75-aa95-49d1-f2dd-c683fc446a85",
+ "trusted": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "10000"
+ ]
+ },
+ "execution_count": 62,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "#Contains the pretrained GloVe weights for the words\n",
+ "len(embedding_matrix)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XWKdr-8zlCby"
+ },
+ "source": [
+ "# Process Input-Output data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 63,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:59:26.036991Z",
+ "iopub.status.busy": "2023-05-20T09:59:26.036413Z",
+ "iopub.status.idle": "2023-05-20T09:59:26.619018Z",
+ "shell.execute_reply": "2023-05-20T09:59:26.617783Z",
+ "shell.execute_reply.started": "2023-05-20T09:59:26.036938Z"
+ },
+ "id": "LF8sHT9ZlCb0",
+ "outputId": "a5c9aa74-4c75-4906-9ccf-0fedc76855e3",
+ "trusted": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[ 0 0 0 ... 4297 7208 5578]\n",
+ " [ 0 0 0 ... 5041 6599 1824]\n",
+ " [ 0 0 0 ... 7208 724 8442]\n",
+ " ...\n",
+ " [ 0 0 0 ... 1700 1792 9924]\n",
+ " [ 0 0 0 ... 4390 9924 4091]\n",
+ " [ 0 0 0 ... 0 9924 6751]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "#One hot representation for input\n",
+ "onehot_repr=[one_hot(words,voc_size)for words in corpus]\n",
+ "\n",
+ "#Finding max words\n",
+ "l = 0\n",
+ "for x in corpus:\n",
+ " l = max(l,len(x.split(' ')))\n",
+ "\n",
+ "#Padding the sequences for input\n",
+ "sent_length= l\n",
+ "embedded_docs=pad_sequences(onehot_repr,padding='pre',maxlen=sent_length)\n",
+ "print(embedded_docs)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 64,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:59:26.620857Z",
+ "iopub.status.busy": "2023-05-20T09:59:26.620459Z",
+ "iopub.status.idle": "2023-05-20T09:59:26.639563Z",
+ "shell.execute_reply": "2023-05-20T09:59:26.638390Z",
+ "shell.execute_reply.started": "2023-05-20T09:59:26.620820Z"
+ },
+ "id": "X0HodJ4KlCb2",
+ "outputId": "10bc981b-eb17-4d70-ddbb-c1c45226be65",
+ "trusted": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([4, 4, 0, ..., 1, 1, 1])"
+ ]
+ },
+ "execution_count": 64,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "#Encoding the target outputs to integers\n",
+ "\n",
+ "label_encoder = preprocessing.LabelEncoder()\n",
+ "\n",
+ "X_final=np.array(embedded_docs) #input to array\n",
+ "y = label_encoder.fit_transform(y)\n",
+ "y_final=np.array(y)\n",
+ "y_final"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 65,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:59:26.641576Z",
+ "iopub.status.busy": "2023-05-20T09:59:26.641076Z",
+ "iopub.status.idle": "2023-05-20T09:59:26.649078Z",
+ "shell.execute_reply": "2023-05-20T09:59:26.647756Z",
+ "shell.execute_reply.started": "2023-05-20T09:59:26.641526Z"
+ },
+ "id": "6U5FPsm7lCb3",
+ "outputId": "32db6f9b-9920-4b20-843f-36fe0fe966b4",
+ "trusted": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((21405, 35), (21405,))"
+ ]
+ },
+ "execution_count": 65,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "X_final.shape,y_final.shape"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {
+ "id": "wbz-EguVKkPn"
+ },
+ "outputs": [],
+ "source": [
+ "# X_final.shape,y_final.shape"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 67,
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:59:26.651285Z",
+ "iopub.status.busy": "2023-05-20T09:59:26.650820Z",
+ "iopub.status.idle": "2023-05-20T09:59:26.667091Z",
+ "shell.execute_reply": "2023-05-20T09:59:26.665786Z",
+ "shell.execute_reply.started": "2023-05-20T09:59:26.651237Z"
+ },
+ "id": "qJk0sfrdlCb7",
+ "trusted": true
+ },
+ "outputs": [],
+ "source": [
+ "#Train-Test split\n",
+ "X_train, X_test, y_train, y_test = train_test_split(X_final, y_final, \n",
+ " test_size=0.2, random_state=42) \n",
+ "#Train-Validation split\n",
+ "X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, \n",
+ " test_size=0.1, random_state=21) "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "I9rP7R_hlCb8"
+ },
+ "source": [
+ "# Create and train model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 68,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:59:26.669280Z",
+ "iopub.status.busy": "2023-05-20T09:59:26.668735Z",
+ "iopub.status.idle": "2023-05-20T09:59:27.399350Z",
+ "shell.execute_reply": "2023-05-20T09:59:27.398529Z",
+ "shell.execute_reply.started": "2023-05-20T09:59:26.669236Z"
+ },
+ "id": "7zPZIpzllCb9",
+ "outputId": "fc47fa21-bc5a-4c92-ed2c-7e6415107435",
+ "trusted": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "2023-05-21 16:30:41.348617: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_2_grad/concat/split_2/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_2_grad/concat/split_2/split_dim}}]]\n",
+ "2023-05-21 16:30:41.350997: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_grad/concat/split/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_grad/concat/split/split_dim}}]]\n",
+ "2023-05-21 16:30:41.352492: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_1_grad/concat/split_1/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_1_grad/concat/split_1/split_dim}}]]\n",
+ "2023-05-21 16:30:41.484768: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis' with dtype int32 and shape [1]\n",
+ "\t [[{{node gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis}}]]\n",
+ "2023-05-21 16:30:41.541351: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_2_grad/concat/split_2/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_2_grad/concat/split_2/split_dim}}]]\n",
+ "2023-05-21 16:30:41.542516: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_grad/concat/split/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_grad/concat/split/split_dim}}]]\n",
+ "2023-05-21 16:30:41.543587: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_1_grad/concat/split_1/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_1_grad/concat/split_1/split_dim}}]]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Model: \"sequential_1\"\n",
+ "_________________________________________________________________\n",
+ " Layer (type) Output Shape Param # \n",
+ "=================================================================\n",
+ " embedding_1 (Embedding) (None, None, 100) 1000000 \n",
+ " \n",
+ " dropout_3 (Dropout) (None, None, 100) 0 \n",
+ " \n",
+ " bidirectional_1 (Bidirectio (None, 128) 84480 \n",
+ " nal) \n",
+ " \n",
+ " dropout_4 (Dropout) (None, 128) 0 \n",
+ " \n",
+ " dense_2 (Dense) (None, 64) 8256 \n",
+ " \n",
+ " dropout_5 (Dropout) (None, 64) 0 \n",
+ " \n",
+ " dense_3 (Dense) (None, 6) 390 \n",
+ " \n",
+ "=================================================================\n",
+ "Total params: 1,093,126\n",
+ "Trainable params: 1,093,126\n",
+ "Non-trainable params: 0\n",
+ "_________________________________________________________________\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Creating model\n",
+ "model=Sequential()\n",
+ "model.add(Embedding(voc_size, embed_size, weights=[embedding_matrix]))\n",
+ "model.add(Dropout(0.3))\n",
+ "model.add(Bidirectional(LSTM(64)))\n",
+ "model.add(Dropout(0.3))\n",
+ "model.add(Dense(64, activation='relu',kernel_regularizer=tf.keras.regularizers.l1(0.01))) #L1 regularization\n",
+ "model.add(Dropout(0.3))\n",
+ "model.add(Dense(6,activation='softmax'))\n",
+ "model.compile(loss='sparse_categorical_crossentropy',optimizer= tf.keras.optimizers.Adam(learning_rate=0.001),\n",
+ " metrics=['accuracy'])\n",
+ "model.summary()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 69,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "execution": {
+ "iopub.execute_input": "2023-05-20T09:59:27.401230Z",
+ "iopub.status.busy": "2023-05-20T09:59:27.400708Z",
+ "iopub.status.idle": "2023-05-20T10:09:23.772878Z",
+ "shell.execute_reply": "2023-05-20T10:09:23.771676Z",
+ "shell.execute_reply.started": "2023-05-20T09:59:27.401194Z"
+ },
+ "id": "oUU5LocrlCb_",
+ "outputId": "7f30824a-d3df-4bd5-f61a-c47811b0103c",
+ "trusted": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 1/40\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "2023-05-21 16:32:31.106806: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_2_grad/concat/split_2/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_2_grad/concat/split_2/split_dim}}]]\n",
+ "2023-05-21 16:32:31.108817: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_grad/concat/split/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_grad/concat/split/split_dim}}]]\n",
+ "2023-05-21 16:32:31.110199: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_1_grad/concat/split_1/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_1_grad/concat/split_1/split_dim}}]]\n",
+ "2023-05-21 16:32:31.269659: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis' with dtype int32 and shape [1]\n",
+ "\t [[{{node gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis}}]]\n",
+ "2023-05-21 16:32:31.318542: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_2_grad/concat/split_2/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_2_grad/concat/split_2/split_dim}}]]\n",
+ "2023-05-21 16:32:31.320160: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_grad/concat/split/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_grad/concat/split/split_dim}}]]\n",
+ "2023-05-21 16:32:31.321939: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_1_grad/concat/split_1/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_1_grad/concat/split_1/split_dim}}]]\n",
+ "2023-05-21 16:32:31.887191: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis' with dtype int32 and shape [1]\n",
+ "\t [[{{node gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis}}]]\n",
+ "2023-05-21 16:32:32.367692: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_2_grad/concat/split_2/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_2_grad/concat/split_2/split_dim}}]]\n",
+ "2023-05-21 16:32:32.371717: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_grad/concat/split/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_grad/concat/split/split_dim}}]]\n",
+ "2023-05-21 16:32:32.377722: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_1_grad/concat/split_1/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_1_grad/concat/split_1/split_dim}}]]\n",
+ "2023-05-21 16:32:32.859124: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis' with dtype int32 and shape [1]\n",
+ "\t [[{{node gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis}}]]\n",
+ "2023-05-21 16:32:32.911182: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_2_grad/concat/split_2/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_2_grad/concat/split_2/split_dim}}]]\n",
+ "2023-05-21 16:32:32.912730: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_grad/concat/split/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_grad/concat/split/split_dim}}]]\n",
+ "2023-05-21 16:32:32.913901: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_1_grad/concat/split_1/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_1_grad/concat/split_1/split_dim}}]]\n",
+ "2023-05-21 16:32:33.506255: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis' with dtype int32 and shape [1]\n",
+ "\t [[{{node gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis}}]]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "241/241 [==============================] - ETA: 0s - loss: 3.5902 - accuracy: 0.3204"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "2023-05-21 16:32:42.970450: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_2_grad/concat/split_2/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_2_grad/concat/split_2/split_dim}}]]\n",
+ "2023-05-21 16:32:42.972854: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_grad/concat/split/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_grad/concat/split/split_dim}}]]\n",
+ "2023-05-21 16:32:42.974329: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_1_grad/concat/split_1/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_1_grad/concat/split_1/split_dim}}]]\n",
+ "2023-05-21 16:32:43.088799: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis' with dtype int32 and shape [1]\n",
+ "\t [[{{node gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis}}]]\n",
+ "2023-05-21 16:32:43.130782: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_2_grad/concat/split_2/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_2_grad/concat/split_2/split_dim}}]]\n",
+ "2023-05-21 16:32:43.132030: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_grad/concat/split/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_grad/concat/split/split_dim}}]]\n",
+ "2023-05-21 16:32:43.132920: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_1_grad/concat/split_1/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_1_grad/concat/split_1/split_dim}}]]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "Epoch 1: val_loss improved from inf to 1.68695, saving model to weights.h5\n",
+ "241/241 [==============================] - 13s 38ms/step - loss: 3.5902 - accuracy: 0.3204 - val_loss: 1.6870 - val_accuracy: 0.2767\n",
+ "Epoch 2/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 1.6294 - accuracy: 0.3261\n",
+ "Epoch 2: val_loss improved from 1.68695 to 1.64050, saving model to weights.h5\n",
+ "241/241 [==============================] - 9s 35ms/step - loss: 1.6297 - accuracy: 0.3261 - val_loss: 1.6405 - val_accuracy: 0.3252\n",
+ "Epoch 3/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 1.6101 - accuracy: 0.3296\n",
+ "Epoch 3: val_loss improved from 1.64050 to 1.63323, saving model to weights.h5\n",
+ "241/241 [==============================] - 8s 33ms/step - loss: 1.6099 - accuracy: 0.3296 - val_loss: 1.6332 - val_accuracy: 0.3252\n",
+ "Epoch 4/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 1.6045 - accuracy: 0.3288\n",
+ "Epoch 4: val_loss improved from 1.63323 to 1.62821, saving model to weights.h5\n",
+ "241/241 [==============================] - 10s 41ms/step - loss: 1.6045 - accuracy: 0.3288 - val_loss: 1.6282 - val_accuracy: 0.3252\n",
+ "Epoch 5/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 1.6012 - accuracy: 0.3324\n",
+ "Epoch 5: val_loss improved from 1.62821 to 1.62768, saving model to weights.h5\n",
+ "241/241 [==============================] - 14s 57ms/step - loss: 1.6012 - accuracy: 0.3324 - val_loss: 1.6277 - val_accuracy: 0.3252\n",
+ "Epoch 6/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 1.6018 - accuracy: 0.3281\n",
+ "Epoch 6: val_loss improved from 1.62768 to 1.62594, saving model to weights.h5\n",
+ "241/241 [==============================] - 13s 52ms/step - loss: 1.6014 - accuracy: 0.3285 - val_loss: 1.6259 - val_accuracy: 0.3252\n",
+ "Epoch 7/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 1.6005 - accuracy: 0.3305\n",
+ "Epoch 7: val_loss improved from 1.62594 to 1.62449, saving model to weights.h5\n",
+ "241/241 [==============================] - 11s 47ms/step - loss: 1.6003 - accuracy: 0.3305 - val_loss: 1.6245 - val_accuracy: 0.3252\n",
+ "Epoch 8/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 1.5703 - accuracy: 0.3316\n",
+ "Epoch 8: val_loss improved from 1.62449 to 1.47578, saving model to weights.h5\n",
+ "241/241 [==============================] - 9s 39ms/step - loss: 1.5703 - accuracy: 0.3316 - val_loss: 1.4758 - val_accuracy: 0.3252\n",
+ "Epoch 9/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 1.3983 - accuracy: 0.3602\n",
+ "Epoch 9: val_loss improved from 1.47578 to 1.34573, saving model to weights.h5\n",
+ "241/241 [==============================] - 9s 37ms/step - loss: 1.3982 - accuracy: 0.3605 - val_loss: 1.3457 - val_accuracy: 0.4133\n",
+ "Epoch 10/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 1.2904 - accuracy: 0.4214\n",
+ "Epoch 10: val_loss improved from 1.34573 to 1.28641, saving model to weights.h5\n",
+ "241/241 [==============================] - 9s 37ms/step - loss: 1.2898 - accuracy: 0.4215 - val_loss: 1.2864 - val_accuracy: 0.4302\n",
+ "Epoch 11/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 1.2354 - accuracy: 0.4309\n",
+ "Epoch 11: val_loss did not improve from 1.28641\n",
+ "241/241 [==============================] - 9s 37ms/step - loss: 1.2354 - accuracy: 0.4309 - val_loss: 1.2871 - val_accuracy: 0.4250\n",
+ "Epoch 12/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 1.1917 - accuracy: 0.4408\n",
+ "Epoch 12: val_loss improved from 1.28641 to 1.24039, saving model to weights.h5\n",
+ "241/241 [==============================] - 12s 51ms/step - loss: 1.1917 - accuracy: 0.4408 - val_loss: 1.2404 - val_accuracy: 0.4308\n",
+ "Epoch 13/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 1.1656 - accuracy: 0.4454\n",
+ "Epoch 13: val_loss improved from 1.24039 to 1.21767, saving model to weights.h5\n",
+ "241/241 [==============================] - 11s 47ms/step - loss: 1.1656 - accuracy: 0.4454 - val_loss: 1.2177 - val_accuracy: 0.4197\n",
+ "Epoch 14/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 1.1413 - accuracy: 0.4498\n",
+ "Epoch 14: val_loss improved from 1.21767 to 1.20062, saving model to weights.h5\n",
+ "241/241 [==============================] - 11s 46ms/step - loss: 1.1411 - accuracy: 0.4499 - val_loss: 1.2006 - val_accuracy: 0.4390\n",
+ "Epoch 15/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 1.1167 - accuracy: 0.4521\n",
+ "Epoch 15: val_loss improved from 1.20062 to 1.16822, saving model to weights.h5\n",
+ "241/241 [==============================] - 10s 39ms/step - loss: 1.1170 - accuracy: 0.4521 - val_loss: 1.1682 - val_accuracy: 0.4448\n",
+ "Epoch 16/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 1.0899 - accuracy: 0.4652\n",
+ "Epoch 16: val_loss improved from 1.16822 to 1.15052, saving model to weights.h5\n",
+ "241/241 [==============================] - 11s 46ms/step - loss: 1.0899 - accuracy: 0.4652 - val_loss: 1.1505 - val_accuracy: 0.4705\n",
+ "Epoch 17/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 1.0645 - accuracy: 0.4841\n",
+ "Epoch 17: val_loss improved from 1.15052 to 1.12788, saving model to weights.h5\n",
+ "241/241 [==============================] - 9s 38ms/step - loss: 1.0645 - accuracy: 0.4841 - val_loss: 1.1279 - val_accuracy: 0.4869\n",
+ "Epoch 18/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 1.0316 - accuracy: 0.4977\n",
+ "Epoch 18: val_loss improved from 1.12788 to 1.11090, saving model to weights.h5\n",
+ "241/241 [==============================] - 9s 39ms/step - loss: 1.0314 - accuracy: 0.4983 - val_loss: 1.1109 - val_accuracy: 0.4915\n",
+ "Epoch 19/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 1.0069 - accuracy: 0.5151\n",
+ "Epoch 19: val_loss improved from 1.11090 to 1.06800, saving model to weights.h5\n",
+ "241/241 [==============================] - 10s 42ms/step - loss: 1.0065 - accuracy: 0.5150 - val_loss: 1.0680 - val_accuracy: 0.5213\n",
+ "Epoch 20/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 0.9658 - accuracy: 0.5507\n",
+ "Epoch 20: val_loss improved from 1.06800 to 0.99474, saving model to weights.h5\n",
+ "241/241 [==============================] - 11s 46ms/step - loss: 0.9658 - accuracy: 0.5506 - val_loss: 0.9947 - val_accuracy: 0.6141\n",
+ "Epoch 21/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 0.8458 - accuracy: 0.6684\n",
+ "Epoch 21: val_loss improved from 0.99474 to 0.84331, saving model to weights.h5\n",
+ "241/241 [==============================] - 10s 43ms/step - loss: 0.8458 - accuracy: 0.6684 - val_loss: 0.8433 - val_accuracy: 0.7215\n",
+ "Epoch 22/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 0.7418 - accuracy: 0.7266\n",
+ "Epoch 22: val_loss improved from 0.84331 to 0.75831, saving model to weights.h5\n",
+ "241/241 [==============================] - 10s 42ms/step - loss: 0.7415 - accuracy: 0.7268 - val_loss: 0.7583 - val_accuracy: 0.7513\n",
+ "Epoch 23/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 0.6759 - accuracy: 0.7495\n",
+ "Epoch 23: val_loss improved from 0.75831 to 0.73188, saving model to weights.h5\n",
+ "241/241 [==============================] - 10s 40ms/step - loss: 0.6759 - accuracy: 0.7495 - val_loss: 0.7319 - val_accuracy: 0.7595\n",
+ "Epoch 24/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 0.6373 - accuracy: 0.7632\n",
+ "Epoch 24: val_loss improved from 0.73188 to 0.70464, saving model to weights.h5\n",
+ "241/241 [==============================] - 11s 47ms/step - loss: 0.6373 - accuracy: 0.7632 - val_loss: 0.7046 - val_accuracy: 0.7764\n",
+ "Epoch 25/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 0.6077 - accuracy: 0.7889\n",
+ "Epoch 25: val_loss improved from 0.70464 to 0.68955, saving model to weights.h5\n",
+ "241/241 [==============================] - 11s 46ms/step - loss: 0.6085 - accuracy: 0.7887 - val_loss: 0.6896 - val_accuracy: 0.7735\n",
+ "Epoch 26/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 0.5817 - accuracy: 0.8018\n",
+ "Epoch 26: val_loss improved from 0.68955 to 0.67606, saving model to weights.h5\n",
+ "241/241 [==============================] - 11s 46ms/step - loss: 0.5817 - accuracy: 0.8018 - val_loss: 0.6761 - val_accuracy: 0.7869\n",
+ "Epoch 27/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 0.5598 - accuracy: 0.8112\n",
+ "Epoch 27: val_loss did not improve from 0.67606\n",
+ "241/241 [==============================] - 12s 50ms/step - loss: 0.5598 - accuracy: 0.8112 - val_loss: 0.6801 - val_accuracy: 0.7834\n",
+ "Epoch 28/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 0.5469 - accuracy: 0.8156\n",
+ "Epoch 28: val_loss improved from 0.67606 to 0.66590, saving model to weights.h5\n",
+ "241/241 [==============================] - 11s 47ms/step - loss: 0.5470 - accuracy: 0.8153 - val_loss: 0.6659 - val_accuracy: 0.7858\n",
+ "Epoch 29/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 0.5245 - accuracy: 0.8189\n",
+ "Epoch 29: val_loss improved from 0.66590 to 0.66082, saving model to weights.h5\n",
+ "241/241 [==============================] - 11s 46ms/step - loss: 0.5245 - accuracy: 0.8189 - val_loss: 0.6608 - val_accuracy: 0.7904\n",
+ "Epoch 30/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 0.5176 - accuracy: 0.8213\n",
+ "Epoch 30: val_loss did not improve from 0.66082\n",
+ "241/241 [==============================] - 15s 63ms/step - loss: 0.5176 - accuracy: 0.8213 - val_loss: 0.6808 - val_accuracy: 0.7858\n",
+ "Epoch 31/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 0.5029 - accuracy: 0.8257\n",
+ "Epoch 31: val_loss improved from 0.66082 to 0.65771, saving model to weights.h5\n",
+ "241/241 [==============================] - 13s 53ms/step - loss: 0.5029 - accuracy: 0.8258 - val_loss: 0.6577 - val_accuracy: 0.7875\n",
+ "Epoch 32/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 0.4986 - accuracy: 0.8307\n",
+ "Epoch 32: val_loss did not improve from 0.65771\n",
+ "241/241 [==============================] - 16s 66ms/step - loss: 0.4991 - accuracy: 0.8306 - val_loss: 0.6790 - val_accuracy: 0.7881\n",
+ "Epoch 33/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 0.4837 - accuracy: 0.8389\n",
+ "Epoch 33: val_loss did not improve from 0.65771\n",
+ "241/241 [==============================] - 12s 48ms/step - loss: 0.4834 - accuracy: 0.8389 - val_loss: 0.6724 - val_accuracy: 0.8027\n",
+ "Epoch 34/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 0.4795 - accuracy: 0.8393\n",
+ "Epoch 34: val_loss did not improve from 0.65771\n",
+ "241/241 [==============================] - 11s 47ms/step - loss: 0.4795 - accuracy: 0.8394 - val_loss: 0.7145 - val_accuracy: 0.7998\n",
+ "Epoch 35/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 0.4717 - accuracy: 0.8504\n",
+ "Epoch 35: val_loss did not improve from 0.65771\n",
+ "241/241 [==============================] - 11s 47ms/step - loss: 0.4717 - accuracy: 0.8504 - val_loss: 0.6981 - val_accuracy: 0.8295\n",
+ "Epoch 36/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 0.4441 - accuracy: 0.8704\n",
+ "Epoch 36: val_loss did not improve from 0.65771\n",
+ "241/241 [==============================] - 11s 47ms/step - loss: 0.4441 - accuracy: 0.8704 - val_loss: 0.6594 - val_accuracy: 0.8354\n",
+ "Epoch 37/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 0.4214 - accuracy: 0.8936\n",
+ "Epoch 37: val_loss improved from 0.65771 to 0.63329, saving model to weights.h5\n",
+ "241/241 [==============================] - 11s 47ms/step - loss: 0.4215 - accuracy: 0.8936 - val_loss: 0.6333 - val_accuracy: 0.8529\n",
+ "Epoch 38/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 0.3965 - accuracy: 0.9042\n",
+ "Epoch 38: val_loss improved from 0.63329 to 0.61591, saving model to weights.h5\n",
+ "241/241 [==============================] - 12s 48ms/step - loss: 0.3965 - accuracy: 0.9042 - val_loss: 0.6159 - val_accuracy: 0.8646\n",
+ "Epoch 39/40\n",
+ "240/241 [============================>.] - ETA: 0s - loss: 0.3824 - accuracy: 0.9096\n",
+ "Epoch 39: val_loss improved from 0.61591 to 0.60107, saving model to weights.h5\n",
+ "241/241 [==============================] - 11s 47ms/step - loss: 0.3822 - accuracy: 0.9097 - val_loss: 0.6011 - val_accuracy: 0.8663\n",
+ "Epoch 40/40\n",
+ "241/241 [==============================] - ETA: 0s - loss: 0.3633 - accuracy: 0.9177\n",
+ "Epoch 40: val_loss did not improve from 0.60107\n",
+ "241/241 [==============================] - 11s 48ms/step - loss: 0.3633 - accuracy: 0.9177 - val_loss: 0.6172 - val_accuracy: 0.8722\n"
+ ]
+ }
+ ],
+ "source": [
+ "model_save = ModelCheckpoint('weights.h5', save_best_only = True, save_weights_only = True, monitor = 'val_loss', \n",
+ " mode = 'min', verbose = 1)\n",
+ "history = model.fit(X_train,y_train,validation_data=(X_val,y_val),epochs=40,batch_size=64,callbacks = [model_save])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 70,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model.save_weights('weights.h5')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 74,
+ "metadata": {
+ "id": "OFRxbEJVsALe"
+ },
+ "outputs": [],
+ "source": [
+ "model.save('final_85.h5')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {
+ "id": "sDz9i_GFEKIT"
+ },
+ "outputs": [],
+ "source": [
+ "model.load_weights('weights.h5')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {
+ "id": "HOk7-wv9nHXD"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "2023-05-21 16:29:45.829060: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_2_grad/concat/split_2/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_2_grad/concat/split_2/split_dim}}]]\n",
+ "2023-05-21 16:29:45.830699: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_grad/concat/split/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_grad/concat/split/split_dim}}]]\n",
+ "2023-05-21 16:29:45.831948: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_1_grad/concat/split_1/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_1_grad/concat/split_1/split_dim}}]]\n",
+ "2023-05-21 16:29:45.948412: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis' with dtype int32 and shape [1]\n",
+ "\t [[{{node gradients/ReverseV2_grad/ReverseV2/ReverseV2/axis}}]]\n",
+ "2023-05-21 16:29:45.990531: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_2_grad/concat/split_2/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_2_grad/concat/split_2/split_dim}}]]\n",
+ "2023-05-21 16:29:45.991895: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_grad/concat/split/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_grad/concat/split/split_dim}}]]\n",
+ "2023-05-21 16:29:45.993047: I tensorflow/core/common_runtime/executor.cc:1197] [/device:CPU:0] (DEBUG INFO) Executor start aborting (this does not indicate an error and you can ignore this message): INVALID_ARGUMENT: You must feed a value for placeholder tensor 'gradients/split_1_grad/concat/split_1/split_dim' with dtype int32\n",
+ "\t [[{{node gradients/split_1_grad/concat/split_1/split_dim}}]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "# from tensorflow.keras.models import load_model\n",
+ "# model = load_model('final_85.h5')\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "02jqaBPqlCcA"
+ },
+ "source": [
+ "# Analysis and visualization of output"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 71,
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2023-05-20T10:09:23.775444Z",
+ "iopub.status.busy": "2023-05-20T10:09:23.774979Z",
+ "iopub.status.idle": "2023-05-20T10:09:24.192821Z",
+ "shell.execute_reply": "2023-05-20T10:09:24.191645Z",
+ "shell.execute_reply.started": "2023-05-20T10:09:23.775394Z"
+ },
+ "id": "JHnSwfJilCcC",
+ "trusted": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "