dl_projekt/lstm.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# LSTM"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "train = pd.read_csv(\"train.csv\")\n",
    "test = pd.read_csv(\"test.csv\")\n",
    "valid = pd.read_csv(\"valid.csv\")\n",
    "\n",
    "train.loc[train[\"review_score\"]==-1, \"review_score\"]=0\n",
    "test.loc[test[\"review_score\"]==-1, \"review_score\"]=0\n",
    "valid.loc[valid[\"review_score\"]==-1, \"review_score\"]=0"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Sprawdzanie długości najdłuższej recenzji (teoretycznie Steam zezwala na max 8000 znaków)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "train[\"seq_length\"] = train[\"review_text\"].apply(lambda x : len(x.split()))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "data": {
      "text/plain": "count    43230.000000\nmean        74.154962\nstd        127.088261\nmin          0.000000\n25%         12.000000\n50%         31.000000\n75%         80.000000\nmax       1570.000000\nName: seq_length, dtype: float64"
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"seq_length\"].describe()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Niektóre recenzje są bardzo długie ale większość jest poniżej 100 słów. W celu przyspieszenia treningu usunę z zestawu treningowego te przykłady, które są dłuższe.\n",
    "\n",
    "*Notka: najpierw próbowałem wytrenować model na sekwencjach długości 1600 tokenów (większych niż najdłuższa recenzja). Model się bardzo długo i bardzo źle trenował.*"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [],
   "source": [
    "#train.drop(train[\"seq_length\"]>200, inplace=True)\n",
    "train.drop(train[train.seq_length > 200].index, inplace=True)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [
    {
     "data": {
      "text/plain": "count    39571.000000\nmean        44.135124\nstd         44.780534\nmin          0.000000\n25%         11.000000\n50%         27.000000\n75%         62.000000\nmax        200.000000\nName: seq_length, dtype: float64"
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"seq_length\"].describe()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "SEQ_PADDED_LENGTH = 200\n",
    "VOCABULARY_SIZE = 4000\n",
    "vectorizer = tf.keras.layers.TextVectorization(output_sequence_length=SEQ_PADDED_LENGTH, max_tokens=VOCABULARY_SIZE)\n",
    "vectorizer.adapt(train[\"review_text\"])"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [
    {
     "data": {
      "text/plain": "4000"
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(vectorizer.get_vocabulary())"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [],
   "source": [
    "train[\"vectorized\"] = train[\"review_text\"].apply(vectorizer)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [],
   "source": [
    "test[\"vectorized\"] = test[\"review_text\"].apply(vectorizer)\n",
    "valid[\"vectorized\"] = valid[\"review_text\"].apply(vectorizer)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_1 (InputLayer)        [(None, 200)]             0         \n",
      "                                                                 \n",
      " embedding (Embedding)       (None, 200, 128)          512128    \n",
      "                                                                 \n",
      " bidirectional (Bidirectiona  (None, 200, 128)         98816     \n",
      " l)                                                              \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 200, 128)          0         \n",
      "                                                                 \n",
      " bidirectional_1 (Bidirectio  (None, 128)              98816     \n",
      " nal)                                                            \n",
      "                                                                 \n",
      " dense (Dense)               (None, 1)                 129       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 709,889\n",
      "Trainable params: 709,889\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "from keras.optimizers import Adam\n",
    "import keras.layers as layers\n",
    "import keras\n",
    "\n",
    "\n",
    "def create_model():\n",
    "    input_layer = layers.Input(shape=(SEQ_PADDED_LENGTH,))\n",
    "    embedding_layer = layers.Embedding(input_dim=VOCABULARY_SIZE+1, output_dim=128, input_length=SEQ_PADDED_LENGTH)(input_layer)\n",
    "    #lstm_layer = layers.LSTM(64)(embedding_layer)\n",
    "    lstm_layer = layers.Bidirectional(layers.LSTM(64, return_sequences=True))(embedding_layer)\n",
    "    dropout_layer = layers.Dropout(0.5)(lstm_layer)\n",
    "    lstm_layer_2 = layers.Bidirectional(layers.LSTM(64))(dropout_layer)\n",
    "    output_layer = layers.Dense(1,activation=\"sigmoid\")(lstm_layer_2)\n",
    "    model = keras.Model(inputs=input_layer, outputs=output_layer)\n",
    "    model.compile(loss='binary_crossentropy', optimizer=Adam(learning_rate=1e-3), metrics=['accuracy'])\n",
    "    return model\n",
    "model = create_model()\n",
    "model.summary()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [
    {
     "data": {
      "text/plain": "TensorShape([200])"
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.iloc[120][\"vectorized\"].shape"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "data": {
      "text/plain": "[200]"
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.iloc[120][\"vectorized\"].get_shape().as_list()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [
    {
     "data": {
      "text/plain": "<tf.Tensor: shape=(200,), dtype=int64, numpy=\narray([ 225, 1120,    2,  113,    1, 1816,    3,  108,   97, 1417,   23,\n         12,   52,   19,  257,   10,    3,   52,   34,    8,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0], dtype=int64)>"
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.iloc[120][\"vectorized\"]"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Część recenzji nie zawierała tekstu więc po usunięciu interpunkcji i znaków specjalnych były puste, teksty te trzeba usunąć z materiału treningowego"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "outputs": [
    {
     "data": {
      "text/plain": "shapes\n200    39452\n0        119\nName: count, dtype: int64"
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train[\"shapes\"] = train[\"vectorized\"].apply(lambda x : x.get_shape().as_list()[0])\n",
    "train[\"shapes\"].value_counts()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "data": {
      "text/plain": "shapes\n200    39452\nName: count, dtype: int64"
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.drop(train[train[\"vectorized\"].map(lambda x : x.get_shape().as_list()[0])!=SEQ_PADDED_LENGTH].index, inplace=True)\n",
    "train[\"shapes\"].value_counts()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "outputs": [
    {
     "data": {
      "text/plain": "     Unnamed: 0 review_text  review_score vectorized\n42      4552590         !!!             1         ()\n124     5286261           .             1         ()\n259     4934066    ........             1         ()\n468     5584357           .             1         ()\n717     2172088          =]             1         ()",
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Unnamed: 0</th>\n      <th>review_text</th>\n      <th>review_score</th>\n      <th>vectorized</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>42</th>\n      <td>4552590</td>\n      <td>!!!</td>\n      <td>1</td>\n      <td>()</td>\n    </tr>\n    <tr>\n      <th>124</th>\n      <td>5286261</td>\n      <td>.</td>\n      <td>1</td>\n      <td>()</td>\n    </tr>\n    <tr>\n      <th>259</th>\n      <td>4934066</td>\n      <td>........</td>\n      <td>1</td>\n      <td>()</td>\n    </tr>\n    <tr>\n      <th>468</th>\n      <td>5584357</td>\n      <td>.</td>\n      <td>1</td>\n      <td>()</td>\n    </tr>\n    <tr>\n      <th>717</th>\n      <td>2172088</td>\n      <td>=]</td>\n      <td>1</td>\n      <td>()</td>\n    </tr>\n  </tbody>\n</table>\n</div>"
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#valid.drop(valid[valid[\"vectorized\"].map(lambda x : x.get_shape().as_list()[0])!=1600].index, inplace=True)\n",
    "\n",
    "empty_valid = valid[valid[\"vectorized\"].map(lambda x : x.get_shape().as_list()[0])==0]\n",
    "empty_valid.head()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "\"0\" to maskowane pozycje, puste dane w zbiorze testowym można nimi uzupełnić"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "outputs": [],
   "source": [
    "#test.loc[test[\"vectorized\"].map(lambda x : x.get_shape().as_list()[0])!=SEQ_PADDED_LENGTH,\"vectorized\"] = tf.zeros((SEQ_PADDED_LENGTH,), dtype=tf.dtypes.int64)\n",
    "#valid.loc[valid[\"vectorized\"].map(lambda x : x.get_shape().as_list()[0])!=SEQ_PADDED_LENGTH,\"vectorized\"] = tf.zeros((SEQ_PADDED_LENGTH,), dtype=tf.dtypes.int64)\n",
    "#empty_valid[\"vectorized\"] = tf.zeros((len(empty_valid.index),1600), dtype=tf.dtypes.int64)\n",
    "#empty_test[\"vectorized\"] = tf.zeros((len(empty_test.index),1600), dtype=tf.dtypes.int64)\n",
    "\n",
    "#empty_valid[\"vectorized\"].iloc[0]\n",
    "\n",
    "def vector_fix(x):\n",
    "    if x.get_shape().as_list()[0]==SEQ_PADDED_LENGTH:\n",
    "        return x\n",
    "    return tf.zeros((SEQ_PADDED_LENGTH,), dtype=tf.dtypes.int64)\n",
    "\n",
    "test[\"vectorized\"] = test[\"vectorized\"].apply(vector_fix)\n",
    "valid[\"vectorized\"] = valid[\"vectorized\"].apply(vector_fix)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "outputs": [],
   "source": [
    "#train[\"vectorized\"] = train[\"vectorized\"].apply(lambda x : x.numpy())\n",
    "#valid[\"vectorized\"] = valid[\"vectorized\"].apply(lambda x : x.numpy())\n",
    "#test[\"vectorized\"] = test[\"vectorized\"].apply(lambda x : x.numpy())"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "outputs": [
    {
     "data": {
      "text/plain": "<tf.Tensor: shape=(200,), dtype=int64, numpy=\narray([  41,   50, 1864,   20,    2,  201,    3,   90,   27,   98,   47,\n          4,  243,   50,  381,  184,    7,  139,  408,   71,   10,    5,\n        120,   14,    2,  688,    2,    3,    9,   48,    1,   30,   85,\n         31,    7,  314,   87,   12,  577,    6,  494,   10,    3,   63,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,\n          0,    0], dtype=int64)>"
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.iloc[0][\"vectorized\"]"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/3\n",
      "1233/1233 [==============================] - 288s 230ms/step - loss: 0.4453 - accuracy: 0.7923 - val_loss: 0.3532 - val_accuracy: 0.8514\n",
      "Epoch 2/3\n",
      "1233/1233 [==============================] - 289s 235ms/step - loss: 0.3145 - accuracy: 0.8669 - val_loss: 0.3272 - val_accuracy: 0.8519\n",
      "Epoch 3/3\n",
      "1233/1233 [==============================] - 289s 234ms/step - loss: 0.2684 - accuracy: 0.8875 - val_loss: 0.3216 - val_accuracy: 0.8635\n"
     ]
    }
   ],
   "source": [
    "#train_y = np.stack(train[\"review_score\"].values)\n",
    "train_y = np.stack(train[\"review_score\"].values)\n",
    "valid_y = np.stack(valid[\"review_score\"].values)\n",
    "\n",
    "test_y = np.stack(test[\"review_score\"].values)\n",
    "\n",
    "###\n",
    "#train_x =  np.stack(train[\"vectorized\"].values)\n",
    "train_x =  np.stack(train[\"vectorized\"].values)\n",
    "\n",
    "test_x = np.stack(test[\"vectorized\"].values)\n",
    "valid_x =  np.stack(valid[\"vectorized\"].values)\n",
    "\n",
    "\n",
    "#callback = keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', patience=3, restore_best_weights=True)\n",
    "history = model.fit(train_x, train_y, validation_data=(valid_x, valid_y), epochs=3)"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "outputs": [],
   "source": [
    "model.save(\"lstm_model.keras\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "outputs": [
    {
     "data": {
      "text/plain": "<matplotlib.legend.Legend at 0x1bf88e819a0>"
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n",
    "plt.title('Wartość funkcji straty')\n",
    "plt.ylabel('Strata')\n",
    "plt.xlabel('Epoka')\n",
    "plt.legend(['train', 'test'], loc='upper left')"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "outputs": [
    {
     "data": {
      "text/plain": "<matplotlib.legend.Legend at 0x1bf8b19f490>"
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\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', 'test'], loc='upper left')"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Dodatkowy trening modelu"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "1233/1233 [==============================] - 273s 222ms/step - loss: 0.2408 - accuracy: 0.9019 - val_loss: 0.3459 - val_accuracy: 0.8605\n",
      "Epoch 2/5\n",
      "1233/1233 [==============================] - 272s 221ms/step - loss: 0.2180 - accuracy: 0.9105 - val_loss: 0.3498 - val_accuracy: 0.8656\n"
     ]
    }
   ],
   "source": [
    "callback = keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', patience=1, restore_best_weights=True)\n",
    "history = model.fit(train_x, train_y, validation_data=(valid_x, valid_y), epochs=5, callbacks=[callback])"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "outputs": [],
   "source": [
    "model.save(\"lstm_model_v2.keras\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Testowanie i ewaluacja modelu"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "def test_review_text(sentence):\n",
    "    vectorized = vectorizer(sentence)\n",
    "    reshaped = tf.reshape(vectorized,shape=(1,200))\n",
    "    #print(vectorized.shape)\n",
    "    score = float(model(reshaped))\n",
    "    score_rounded = round(score)\n",
    "    print(score)\n",
    "    if score_rounded==0:\n",
    "        print(\"Negative review\")\n",
    "    else:\n",
    "        print(\"Positive review\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.02259424328804016\n",
      "Negative review\n"
     ]
    }
   ],
   "source": [
    "test_review_text(\"A buggy, uninspired mess\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.066298708319664\n",
      "Negative review\n"
     ]
    }
   ],
   "source": [
    "test_review_text(\"This game is bad\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9277510643005371\n",
      "Positive review\n"
     ]
    }
   ],
   "source": [
    "test_review_text(\"This game destroyed my life\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.990617036819458\n",
      "Positive review\n"
     ]
    }
   ],
   "source": [
    "test_review_text(\"Best game I've ever played\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9053470492362976\n",
      "Positive review\n"
     ]
    }
   ],
   "source": [
    "test_review_text(\"Fun cooperative play with scalable difficulty. Rapid path to get into a game with friends or open public games. \")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3265230357646942\n",
      "Negative review\n"
     ]
    }
   ],
   "source": [
    "test_review_text(\"Deliriously buggy. Fun if/when it works properly. Wait and see if they actually QA the next few patches before you play.\")"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "outputs": [],
   "source": [
    "test[\"model_predictions\"] = model(np.stack(test[\"vectorized\"].values))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "outputs": [],
   "source": [
    "test[\"model_predictions\"] = test[\"model_predictions\"].apply(lambda x : round(float(x)))"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.86\n",
      "Precision: 0.97\n",
      "Recall: 0.86\n",
      "F1 Score: 0.91\n"
     ]
    }
   ],
   "source": [
    "def get_metrics():\n",
    "    df = test\n",
    "    predictions = df[\"model_predictions\"].to_numpy()\n",
    "    true_values = df[\"review_score\"].to_numpy()\n",
    "    accuracy = np.sum(np.rint(predictions) == true_values)/len(true_values)\n",
    "    TN_count = len(df.query(\"`review_score`==0 and `model_predictions`==0\").index)\n",
    "    TP_count = len(df.query(\"`review_score`==1 and `model_predictions`==1\").index)\n",
    "    FP_count = len(df.query(\"`review_score`==0 and `model_predictions`==1\").index)\n",
    "    FN_count = len(df.query(\"`review_score`==1 and `model_predictions`==0\").index)\n",
    "    precision = TP_count/(TP_count+FP_count)\n",
    "    recall = TP_count/(TP_count+FN_count)\n",
    "    F1_score = (2*precision*recall)/(precision+recall)\n",
    "    print(f\"Accuracy: {accuracy:.2f}\")\n",
    "    print(f\"Precision: {precision:.2f}\")\n",
    "    print(f\"Recall: {recall:.2f}\")\n",
    "    print(f\"F1 Score: {F1_score:.2f}\")\n",
    "get_metrics()"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}