{ "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", " \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", "
TextEmotion
0i didnt feel humiliatedsadness
1i can go from feeling so hopeless to so damned...sadness
2im grabbing a minute to post i feel greedy wronganger
3i am ever feeling nostalgic about the fireplac...love
4i am feeling grouchyanger
\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", " \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", "
TextEmotion
11898i am feeling stressed and more than a bit anxioussadness
16501i am feeling stressed and more than a bit anxiousanger
8246i am not amazing or great at photography but i...love
3508i am not amazing or great at photography but i...happy
15704i began to feel accepted by gaia on her own termshappy
.........
11354i write these words i feel sweet baby kicks fr...love
7685im still not sure why reilly feels the need to...surprise
2908im still not sure why reilly feels the need to...fear
9069ive also made it with both sugar measurements ...love
9596ive also made it with both sugar measurements ...happy
\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": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "print(history.history.keys())\n", "# \"Accuracy\"\n", "plt.plot(history.history['accuracy'])\n", "plt.plot(history.history['val_accuracy'])\n", "plt.title('model accuracy')\n", "plt.ylabel('accuracy')\n", "plt.xlabel('epoch')\n", "plt.legend(['train', 'validation'], loc='upper left')\n", "plt.show()\n", "# \"Loss\"\n", "plt.plot(history.history['loss'])\n", "plt.plot(history.history['val_loss'])\n", "plt.title('model loss')\n", "plt.ylabel('loss')\n", "plt.xlabel('epoch')\n", "plt.legend(['train', 'validation'], loc='upper left')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "execution": { "iopub.execute_input": "2023-05-20T10:09:24.194864Z", "iopub.status.busy": "2023-05-20T10:09:24.194475Z", "iopub.status.idle": "2023-05-20T10:09:24.216702Z", "shell.execute_reply": "2023-05-20T10:09:24.215649Z", "shell.execute_reply.started": "2023-05-20T10:09:24.194825Z" }, "id": "jV5LLEOOlCcD", "trusted": true }, "outputs": [], "source": [ "#Load the best weights\n", "model.load_weights('/home/devraj4522/Desktop/ML Model/weights.h5')" ] }, { "cell_type": "code", "execution_count": 73, "metadata": { "execution": { "iopub.execute_input": "2023-05-20T10:09:40.302034Z", "iopub.status.busy": "2023-05-20T10:09:40.301389Z", "iopub.status.idle": "2023-05-20T10:09:41.633835Z", "shell.execute_reply": "2023-05-20T10:09:41.633021Z", "shell.execute_reply.started": "2023-05-20T10:09:40.301990Z" }, "id": "n7Grs9jClCcE", "trusted": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2023-05-21 16:40:36.174455: 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:40:36.175716: 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:40:36.176735: 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:40:36.319947: 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:40:36.386568: 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:40:36.389505: 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:40:36.392537: 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": [ "134/134 [==============================] - 1s 6ms/step\n" ] } ], "source": [ "y_pred_probabilities=model.predict(X_test)\n", "y_pred = np.argmax(y_pred_probabilities, axis=1)" ] }, { "cell_type": "code", "execution_count": 74, "metadata": { "execution": { "iopub.execute_input": "2023-05-20T10:09:26.304836Z", "iopub.status.busy": "2023-05-20T10:09:26.304479Z", "iopub.status.idle": "2023-05-20T10:09:26.311888Z", "shell.execute_reply": "2023-05-20T10:09:26.310637Z", "shell.execute_reply.started": "2023-05-20T10:09:26.304801Z" }, "id": "5Zbs6VAclCcF", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.8710581639803784\n" ] } ], "source": [ "#Accuracy score\n", "print(accuracy_score(y_test,y_pred))" ] }, { "cell_type": "code", "execution_count": 82, "metadata": { "execution": { "iopub.execute_input": "2023-05-20T10:09:26.314995Z", "iopub.status.busy": "2023-05-20T10:09:26.314169Z", "iopub.status.idle": "2023-05-20T10:09:26.338393Z", "shell.execute_reply": "2023-05-20T10:09:26.337071Z", "shell.execute_reply.started": "2023-05-20T10:09:26.314947Z" }, "id": "Q1wod4WAlCcI", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " precision recall f1-score support\n", "\n", " 0 0.81955 0.87061 0.84431 626\n", " 1 0.82911 0.74432 0.78443 528\n", " 2 0.90253 0.90658 0.90455 1338\n", " 3 0.77409 0.73734 0.75527 316\n", " 4 0.91851 0.93127 0.92485 1295\n", " 5 0.75543 0.78090 0.76796 178\n", "\n", " accuracy 0.87106 4281\n", " macro avg 0.83320 0.82850 0.83023 4281\n", "weighted avg 0.87058 0.87106 0.87037 4281\n", "\n" ] } ], "source": [ "#Classification report\n", "print(classification_report(y_test, y_pred, digits=5))" ] }, { "cell_type": "code", "execution_count": 76, "metadata": { "execution": { "iopub.execute_input": "2023-05-20T10:09:26.340796Z", "iopub.status.busy": "2023-05-20T10:09:26.340283Z", "iopub.status.idle": "2023-05-20T10:09:26.749743Z", "shell.execute_reply": "2023-05-20T10:09:26.748548Z", "shell.execute_reply.started": "2023-05-20T10:09:26.340749Z" }, "id": "jn9_dM3UlCcJ", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Confusion Matrix\n", "Axes(0.125,0.11;0.62x0.77)\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#Confusion Matrix\n", "print('Confusion Matrix')\n", "print(sns.heatmap(confusion_matrix(y_test, y_pred),annot=True,fmt=\"d\"))" ] }, { "cell_type": "markdown", "metadata": { "id": "iRM4Ra1hlCcK" }, "source": [ "# Test on own" ] }, { "cell_type": "code", "execution_count": 77, "metadata": { "execution": { "iopub.execute_input": "2023-05-20T10:09:26.753363Z", "iopub.status.busy": "2023-05-20T10:09:26.753015Z", "iopub.status.idle": "2023-05-20T10:09:26.759208Z", "shell.execute_reply": "2023-05-20T10:09:26.758118Z", "shell.execute_reply.started": "2023-05-20T10:09:26.753328Z" }, "id": "DrZLn1A8lCcL", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'anger': 0, 'fear': 1, 'happy': 2, 'love': 3, 'sadness': 4, 'surprise': 5}\n" ] } ], "source": [ "#Mapping of target classes using label-encoder\n", "le_name_mapping = dict(zip(label_encoder.classes_, label_encoder.transform(label_encoder.classes_)))\n", "print(le_name_mapping)" ] }, { "cell_type": "code", "execution_count": 78, "metadata": { "execution": { "iopub.execute_input": "2023-05-20T10:09:26.761931Z", "iopub.status.busy": "2023-05-20T10:09:26.761410Z", "iopub.status.idle": "2023-05-20T10:09:26.774147Z", "shell.execute_reply": "2023-05-20T10:09:26.772893Z", "shell.execute_reply.started": "2023-05-20T10:09:26.761877Z" }, "id": "wzW8oQt6lCcM", "trusted": true }, "outputs": [], "source": [ "#Example\n", "def predict_emotion(stri):\n", " review = re.sub('[^a-zA-Z]', ' ', stri)\n", " review = review.lower()\n", " review = review.split()\n", " review = [ps.stem(word) for word in review if not word in stopwords_list]\n", " review = ' '.join(review)\n", " onehot_repr = [one_hot(review,voc_size)] \n", " embed = pad_sequences(onehot_repr,padding='pre',maxlen=sent_length)\n", " predicti = model.predict(embed)\n", " return label_encoder.classes_[np.argmax(predicti)]" ] }, { "cell_type": "code", "execution_count": 79, "metadata": { "execution": { "iopub.execute_input": "2023-05-20T10:09:26.778202Z", "iopub.status.busy": "2023-05-20T10:09:26.777847Z", "iopub.status.idle": "2023-05-20T10:09:26.840189Z", "shell.execute_reply": "2023-05-20T10:09:26.838933Z", "shell.execute_reply.started": "2023-05-20T10:09:26.778168Z" }, "id": "LW4Pkt-glCcN", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1/1 [==============================] - 0s 24ms/step\n" ] }, { "data": { "text/plain": [ "'happy'" ] }, "execution_count": 79, "metadata": {}, "output_type": "execute_result" } ], "source": [ "predict_emotion('happy')" ] }, { "cell_type": "code", "execution_count": 80, "metadata": { "execution": { "iopub.execute_input": "2023-05-20T10:09:26.842402Z", "iopub.status.busy": "2023-05-20T10:09:26.841919Z", "iopub.status.idle": "2023-05-20T10:09:26.897067Z", "shell.execute_reply": "2023-05-20T10:09:26.896026Z", "shell.execute_reply.started": "2023-05-20T10:09:26.842352Z" }, "id": "M541tSFMlCcP", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1/1 [==============================] - 0s 53ms/step\n" ] }, { "data": { "text/plain": [ "'anger'" ] }, "execution_count": 80, "metadata": {}, "output_type": "execute_result" } ], "source": [ "predict_emotion('He is an arrogant and rude person')" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "execution": { "iopub.execute_input": "2023-05-20T10:09:26.898895Z", "iopub.status.busy": "2023-05-20T10:09:26.898534Z", "iopub.status.idle": "2023-05-20T10:09:26.956789Z", "shell.execute_reply": "2023-05-20T10:09:26.955930Z", "shell.execute_reply.started": "2023-05-20T10:09:26.898863Z" }, "id": "Wu26JSumlCcQ", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1/1 [==============================] - 0s 27ms/step\n" ] }, { "data": { "text/plain": [ "'anger'" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "predict_emotion('The teacher is intimidating and scary')" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "execution": { "iopub.execute_input": "2023-05-20T10:21:53.561844Z", "iopub.status.busy": "2023-05-20T10:21:53.561391Z", "iopub.status.idle": "2023-05-20T10:21:53.619872Z", "shell.execute_reply": "2023-05-20T10:21:53.618661Z", "shell.execute_reply.started": "2023-05-20T10:21:53.561804Z" }, "id": "78VBA7mhlCcS", "trusted": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1/1 [==============================] - 0s 22ms/step\n" ] }, { "data": { "text/plain": [ "'anger'" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "predict_emotion('love')" ] }, { "cell_type": "code", "execution_count": 81, "metadata": { "id": "K81q9SIqXKZD" }, "outputs": [], "source": [ "model_json = model.to_json()\n", "with open(\"model_architecture.json\", \"w\") as json_file:\n", " json_file.write(model_json)" ] } ], "metadata": { "colab": { "provenance": [] }, "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.10.6" } }, "nbformat": 4, "nbformat_minor": 0 }