{ "cells": [ { "cell_type": "markdown", "source": [ "### TFIDF --> Feedforward Neural Network" ], "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": "code", "execution_count": 2, "outputs": [ { "data": { "text/plain": "review_score\n0 21615\n1 21615\nName: count, dtype: int64" }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "train[\"review_score\"].value_counts()" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 3, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "RangeIndex: 43230 entries, 0 to 43229\n", "Data columns (total 3 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 Unnamed: 0 43230 non-null int64 \n", " 1 review_text 43230 non-null object\n", " 2 review_score 43230 non-null int64 \n", "dtypes: int64(2), object(1)\n", "memory usage: 1013.3+ KB\n" ] } ], "source": [ "train.info()" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 4, "outputs": [], "source": [ "from sklearn.feature_extraction.text import TfidfVectorizer\n", "\n", "input_vectorizer = TfidfVectorizer(stop_words=\"english\",strip_accents=\"ascii\",max_features=4096, norm=\"l1\")" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 5, "outputs": [], "source": [ "input_vectorizer = input_vectorizer.fit(train[\"review_text\"])" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 72, "outputs": [], "source": [ "train[\"vectorized\"] = train[\"review_text\"].apply(lambda x : input_vectorizer.transform([x]).toarray()[0])" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 73, "outputs": [ { "data": { "text/plain": "\"I'm the biggest fan you will ever meet of tile-based rpgs. Lands of Lore! Eye of the Beholder! YES!! I've been playing Xeen since '92. Why doesn't someone make a game like that again?!! No seriously, let me know if you see one, because that's what this game seems to be going for but it sadly misses the mark. I would be more forgiving and I would even give this game a positive except that the mis-steps they took are downright bewildering. First what do I love about this title... It really is incredibly challenging. The puzzles, battles, and resource management is unforgiving which is a nice throwback to the 'good old days'. I love that they took that risk here, because usually it makes the difference between a grind and compelling, rewarding gameplay. Grimrock is a nice reminder of the days when games weren't all just an endurance contest, and not everyone could beat every game given enough time. The first thing you'll notice is that this game is fun. Actually, really fun. You can jump right in without any help and start adventuring. The puzzles feel like first-person zelda and the written 'clues' are a great homage to the first-generation of PC rpg titles. I love the creepy dream sequences, and the customizable party pics are a great touch that is long overdue. The biggest issue this game struggles with slowly becomes apparent with the combat system. There is a gaping hole in what should be simple mechanics and functionality of the UI and especially combat. The spellcasting system is pretty original, but the act of casting like other actions just doesn't jive with 'real-time' battle. Every battle quickly devolves into a scramble to CLICK ALL THE THINGS and it often leaves the player feeling cheated when things go wrong, especially considering how clunky the menus can be. The frenzy of battle becomes a tedium of switching gear, passing potions around, and constantly equipping new projectiles. There are no hot keys, you pretty much have to rely on the mouse for everything. The cerebral aspects of the game (puzzles, carefully managing resources, distributing skill points) is lost every time you encounter an enemy, because battle feels too much like a chore rather than fun. To excel in this combat system you have to play a perpetual game of hopscotch with your enemies as you desperately try to click the next action square that lights up at the right time. In addition, the characters here can't seem to hit the broad side of a barn. Had this game incorporated turn-based combat or at least an option for it, this game still wouldn't be a home run but this would be a positive review. I love that these devs dusted off an sadly neglected style of RPG, but other than a nice facelift there's not much else to see here. I respect the risks they took here but the potential here is tragically lost in the tedium of the clunky and frenzied comat system and a general lack of polish. You get 4 party members and there are 3 classes. Scarce resources is one thing I respect, but for an RPG the equipment is so scarce that your characters are still half-naked 8 hours into the game. Thrown weapons, torches, and food all need to be perpetually 'maintained', and inventory management becomes a chore. There seem to be no status icons, save for 'over-encumbered', which doesn't even seem to function properly as the numbers don't make sense. Maybe as part of the homage to old games they decided to add a dash of 'WTF' just for good measure I don't know what else to chalk some of this up to. There's something here for those of us who remember this classic style, but this just feels like a poorly designed RPG reluctantly wedged into a brilliant dungeon puzzler. Maybe it would be great on a tablet for poop breaks, but as a PC title it feels half-baked. I haven't played the sequel yet but I'm hopeful that they learned some things from this release and improved on what is an intriguing foundation here. I'm not giving up on this series. Don't get me wrong, despite the mis-steps there really is a lot of potential here. I give it 2 out of 4 skeleton archers, with skeleton-shaped shadow lurking in the corner chattering 'tuuuuurn-BASED!!' and another chattering 'statusssss iconssssss...master warp portalsssssss between levels...one or two more classsesss......chchchchchchchhc'\"" }, "execution_count": 73, "metadata": {}, "output_type": "execute_result" } ], "source": [ "train[\"review_text\"].iloc[0]" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 74, "outputs": [ { "data": { "text/plain": "array([0., 0., 0., ..., 0., 0., 0.])" }, "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ "train[\"vectorized\"].iloc[0]" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 75, "outputs": [ { "data": { "text/plain": "199" }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.count_nonzero(train[\"vectorized\"].iloc[0])" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 50, "outputs": [], "source": [ "test[\"vectorized\"] = test[\"review_text\"].apply(lambda x : input_vectorizer.transform([x]).toarray()[0])\n", "valid[\"vectorized\"] = valid[\"review_text\"].apply(lambda x : input_vectorizer.transform([x]).toarray()[0])" ], "metadata": { "collapsed": false } }, { "cell_type": "markdown", "source": [ "Po kilku próbach przy których model bardzo źle sobie radził, dodałem jedną warstwę więcej i zwiększyłem liczbę neuronów w warstwach ukrytych. Zwiększyłem też wielkość embeddingów tf-idf do 4096. Po tych zmianach lepiej się wytrenował." ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 77, "outputs": [], "source": [ "import tensorflow as tf\n", "from tensorflow import keras\n", "from keras import layers\n", "from keras.optimizers import Adam\n", "\n", "def create_model():\n", " inputs = keras.Input(shape=(4096,))\n", " dense1 = layers.Dense(1024, activation=\"relu\")(inputs)\n", " dense2 = layers.Dense(512, activation=\"relu\")(dense1)\n", " dense3 = layers.Dense(128, activation=\"relu\")(dense2)\n", " output = layers.Dense(1, activation=\"sigmoid\")(dense3)\n", " model = keras.Model(inputs=inputs, outputs=output)\n", " model.compile(loss='binary_crossentropy', optimizer=Adam(learning_rate=1e-4), metrics=['accuracy'])\n", " return model" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 78, "outputs": [ { "data": { "text/plain": "array([0., 0., 0., ..., 0., 0., 0.])" }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "train[\"vectorized\"].iloc[0]" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 79, "outputs": [ { "data": { "text/plain": "0" }, "execution_count": 79, "metadata": {}, "output_type": "execute_result" } ], "source": [ "train[\"review_score\"].iloc[0]" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 80, "outputs": [], "source": [ "train_x = np.stack(train[\"vectorized\"].values)\n", "train_y = np.stack(train[\"review_score\"].values)\n", "\n", "valid_x = np.stack(valid[\"vectorized\"].values)\n", "valid_y = np.stack(valid[\"review_score\"].values)\n", "\n", "test_x = np.stack(test[\"vectorized\"].values)\n", "test_y = np.stack(test[\"review_score\"].values)" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 81, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch 1/25\n", "1351/1351 [==============================] - 15s 11ms/step - loss: 0.4557 - accuracy: 0.7972 - val_loss: 0.4194 - val_accuracy: 0.8150\n", "Epoch 2/25\n", "1351/1351 [==============================] - 15s 11ms/step - loss: 0.3468 - accuracy: 0.8525 - val_loss: 0.3864 - val_accuracy: 0.8257\n", "Epoch 3/25\n", "1351/1351 [==============================] - 16s 12ms/step - loss: 0.3006 - accuracy: 0.8706 - val_loss: 0.3710 - val_accuracy: 0.8488\n", "Epoch 4/25\n", "1351/1351 [==============================] - 15s 11ms/step - loss: 0.2564 - accuracy: 0.8908 - val_loss: 0.4160 - val_accuracy: 0.8260\n", "Epoch 5/25\n", "1351/1351 [==============================] - 15s 11ms/step - loss: 0.2038 - accuracy: 0.9153 - val_loss: 0.4832 - val_accuracy: 0.8182\n", "Epoch 6/25\n", "1351/1351 [==============================] - 15s 11ms/step - loss: 0.1435 - accuracy: 0.9416 - val_loss: 0.5748 - val_accuracy: 0.8140\n", "Epoch 7/25\n", "1351/1351 [==============================] - 15s 11ms/step - loss: 0.0967 - accuracy: 0.9598 - val_loss: 0.7156 - val_accuracy: 0.8019\n", "Epoch 8/25\n", "1351/1351 [==============================] - 15s 11ms/step - loss: 0.0636 - accuracy: 0.9743 - val_loss: 0.7932 - val_accuracy: 0.8284\n" ] } ], "source": [ "callback = keras.callbacks.EarlyStopping(monitor='val_loss', mode='min', patience=5, restore_best_weights=True)\n", "model = create_model()\n", "history = model.fit(train_x, train_y, validation_data=(valid_x, valid_y), epochs=25, callbacks=[callback])" ], "metadata": { "collapsed": false } }, { "cell_type": "markdown", "source": [ "### Model był przetrenowany (overfitting) pod koniec treningu:" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 84, "outputs": [ { "data": { "text/plain": "" }, "execution_count": 84, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": "
", "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": 85, "outputs": [ { "data": { "text/plain": "" }, "execution_count": 85, "metadata": {}, "output_type": "execute_result" }, { "data": { "text/plain": "
", "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": "code", "execution_count": 86, "outputs": [], "source": [ "model.save(\"tfidf_model.keras\")" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 7, "outputs": [], "source": [ "import keras\n", "model = keras.models.load_model('tfidf_model.keras')" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 37, "outputs": [], "source": [ "import tensorflow as tf\n", "def test_review_text(sentence):\n", " vectorized = input_vectorizer.transform([sentence]).toarray()[0]\n", " reshaped = tf.reshape(vectorized,shape=(1,4096))\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": 47, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.0009309111046604812\n", "Negative review\n" ] } ], "source": [ "test_review_text(\"A buggy, uninspired mess\")" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 39, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.31012997031211853\n", "Negative review\n" ] } ], "source": [ "test_review_text(\"This game is bad\")" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 40, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.7850202918052673\n", "Positive review\n" ] } ], "source": [ "test_review_text(\"This game destroyed my life\")" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 41, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.9888448715209961\n", "Positive review\n" ] } ], "source": [ "test_review_text(\"Best game I've ever played\")" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 45, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.7033981680870056\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": 46, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.2961832880973816\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": 52, "outputs": [], "source": [ "test[\"model_predictions\"] = model(np.stack(test[\"vectorized\"].values))" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 53, "outputs": [], "source": [ "test[\"model_predictions\"] = test[\"model_predictions\"].apply(lambda x : round(float(x)))" ], "metadata": { "collapsed": false } }, { "cell_type": "code", "execution_count": 57, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Accuracy: 0.85\n", "Precision: 0.96\n", "Recall: 0.86\n", "F1 Score: 0.90\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 }