MBTI-Predictor-Oversampling.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as np\n",
    "df = np.read_csv('mbti_1.csv')\n",
    "\n",
    "# populating types array\n",
    "types = []\n",
    "for _type in df['type']:\n",
    "     types.append(_type)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "tokenized_posts = []\n",
    "with open ('tokenized_formatted_data.txt', 'rb') as fp:\n",
    "    tokenized_posts = pickle.load(fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "random.seed(673)\n",
    "random.shuffle(types)\n",
    "random.seed(673)\n",
    "random.shuffle(tokenized_posts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "with open ('synthetic_data.pkl', 'rb') as fp:\n",
    "    synthetic_data = pickle.load(fp)\n",
    "    \n",
    "for labels, users in synthetic_data:\n",
    "    for i in range(0, len(labels)):\n",
    "        types.append(labels[i])\n",
    "        tokenized_posts.append(users[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29312"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(types)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_words_list = []\n",
    "\n",
    "for user in tokenized_posts:\n",
    "    for word in user:\n",
    "        all_words_list.append(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "freq_list = Counter(all_words_list)\n",
    "dictionary = freq_list.most_common(10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionary = list(zip(*dictionary))[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = range(0, 10000)\n",
    "word_int = dict(zip(dictionary, nums))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_vals = []\n",
    "for user in tokenized_posts:\n",
    "    x_vals.append([word_int[x] for x in user if x in word_int.keys()])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "intr_extr = [word[0:1] for word in types]\n",
    "\n",
    "for letter in intr_extr:\n",
    "    if (letter == 'I'):\n",
    "        bin_intro_extro.append(0)\n",
    "    else:\n",
    "        bin_intro_extro.append(1)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "temp = []\n",
    "for i in range(0,8675):\n",
    "    row = []\n",
    "    row.append(types[i])\n",
    "    row.append(tokenized_posts[i])\n",
    "    temp.append(row)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "temp = sorted(temp)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "types = []\n",
    "x_vals = []\n",
    "for i in range(0, 8675):\n",
    "    types.append(temp[i][0])\n",
    "    x_vals.append(temp[i][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = x_vals[1000:]\n",
    "y_train = types[1000:]\n",
    "\n",
    "x_test = x_vals[:1000]\n",
    "y_test = types[:1000]"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "current_type = types[0]\n",
    "counter = 0\n",
    "last_change = 0\n",
    "\n",
    "for i in range(0, 8675):\n",
    "    if types[i] != current_type or i == 8674:\n",
    "        end_index = last_change + round(counter - counter/10)\n",
    "        counter += last_change\n",
    "        \n",
    "        if (i == 8674):\n",
    "            counter += 1\n",
    "        \n",
    "        for j in range(last_change, end_index):\n",
    "            x_train.append(x_vals[j])\n",
    "            y_train.append(types[j])\n",
    "        \n",
    "        for j in range(end_index, counter):\n",
    "            x_test.append(x_vals[j])\n",
    "            y_test.append(types[j])\n",
    "        \n",
    "        last_change = i\n",
    "        counter = 1\n",
    "        current_type = types[i]\n",
    "        continue\n",
    "    counter += 1\n",
    "        "
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "with open('train_posts.pkl', 'wb') as fw:\n",
    "    pickle.dump(x_train, fw)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "type_dictionary = {\n",
    "    '0000':'INTJ',\n",
    "    '0001':'INTP',\n",
    "    '0010':'INFJ',\n",
    "    '0011':'INFP',\n",
    "    '0100':'ISTJ',\n",
    "    '0101':'ISTP',\n",
    "    '0110':'ISFJ',\n",
    "    '0111':'ISFP',\n",
    "    '1000':'ENTJ',\n",
    "    '1001':'ENTP',\n",
    "    '1010':'ENFJ',\n",
    "    '1011':'ENFP',\n",
    "    '1100':'ESTJ',\n",
    "    '1101':'ESTP',\n",
    "    '1110':'ESFJ',\n",
    "    '1111':'ESFP',\n",
    "}\n",
    "\n",
    "type_labels=['INTJ','INTP','INFJ','INFP','ISTJ','ISTP','ISFJ','ISFP', \\\n",
    "        'ENTJ','ENTP','ENFJ','ENFP','ESTJ','ESTP','ESFJ','ESFP',]\n",
    "\n",
    "def to_one_hot(arr):\n",
    "    one_hot_types = []\n",
    "\n",
    "    for label in arr:\n",
    "        bin_type = []\n",
    "\n",
    "        if (label[0] == 'I'):\n",
    "            bin_type.append(0)\n",
    "        else:\n",
    "            bin_type.append(1)\n",
    "\n",
    "        if (label[1] == 'N'):\n",
    "            bin_type.append(0)\n",
    "        else:\n",
    "            bin_type.append(1)\n",
    "\n",
    "        if (label[2] == 'T'):\n",
    "            bin_type.append(0)\n",
    "        else:\n",
    "            bin_type.append(1)\n",
    "\n",
    "        if (label[3] == 'J'):\n",
    "            bin_type.append(0)\n",
    "        else:\n",
    "            bin_type.append(1)\n",
    "\n",
    "        one_hot_types.append(bin_type)\n",
    "        \n",
    "    return one_hot_types\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from keras.utils.np_utils import to_categorical\n",
    "\n",
    "def vectorize_sequences(sequences, dimension=10000):\n",
    "    results = np.zeros((len(sequences), dimension))\n",
    "    for i, sequence in enumerate(sequences):\n",
    "        results[i, sequence] = 1.\n",
    "    return results\n",
    "\n",
    "x_train = vectorize_sequences(x_train)\n",
    "x_test = vectorize_sequences(x_test)\n",
    "\n",
    "y_train = np.asarray(to_one_hot(y_train)).astype('float32')\n",
    "y_test = np.asarray(to_one_hot(y_test)).astype('float32')"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "import numpy as np\n",
    "import random\n",
    "\n",
    "x = np.array(x_vals)\n",
    "test_data = x[:1500]\n",
    "train_data = x[1500:]\n",
    "\n",
    "def vectorize_sequences(sequences, dimension=10000):\n",
    "    results = np.zeros((len(sequences), dimension))\n",
    "    for i, sequence in enumerate(sequences):\n",
    "        results[i, sequence] = 1.\n",
    "    return results\n",
    "\n",
    "x_train = vectorize_sequences(train_data)\n",
    "x_test = vectorize_sequences(test_data)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "from keras.utils.np_utils import to_categorical\n",
    "\n",
    "y = np.asarray(one_hot_types).astype('float32')\n",
    "y_test = y[:1500]\n",
    "y_train = y[1500:]"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "x_val = x_train[:1500]\n",
    "x_partial_train = x_train[1500:]\n",
    "\n",
    "y_val = y_train[:1500]\n",
    "y_partial_train = y_train[1500:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_weights = {\n",
    "    0:1.,\n",
    "    1:3.03,\n",
    "    2:1.,\n",
    "    3:5.35,\n",
    "    4:1.,\n",
    "    5:1.12,\n",
    "    6:1.,\n",
    "    7:0.69\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FEED FORWARD MODEL\n",
    "from keras import models\n",
    "from keras import layers\n",
    "from keras import regularizers\n",
    "import tensorflow as tf\n",
    "def build_model():\n",
    "    model = models.Sequential()\n",
    "    model.add(layers.Dense(16, kernel_regularizer=regularizers.l2(0.001),\n",
    "                           activation='relu', input_shape = (10000,)))\n",
    "    model.add(layers.Dense(16, kernel_regularizer=regularizers.l2(0.001),\n",
    "                           activation='relu'))\n",
    "    model.add(layers.Dense(4, activation='sigmoid'))\n",
    "    model.compile(optimizer = 'rmsprop',\n",
    "                  loss = 'binary_crossentropy',\n",
    "                  metrics = ['acc'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "28312/28312 [==============================] - 6s 212us/step - loss: 0.4266 - acc: 0.8378\n",
      "Epoch 2/10\n",
      "28312/28312 [==============================] - 3s 103us/step - loss: 0.3059 - acc: 0.9084\n",
      "Epoch 3/10\n",
      "28312/28312 [==============================] - 3s 97us/step - loss: 0.2737 - acc: 0.9224\n",
      "Epoch 4/10\n",
      "28312/28312 [==============================] - 3s 97us/step - loss: 0.2568 - acc: 0.9301\n",
      "Epoch 5/10\n",
      "28312/28312 [==============================] - 3s 96us/step - loss: 0.2453 - acc: 0.9349\n",
      "Epoch 6/10\n",
      "28312/28312 [==============================] - 3s 98us/step - loss: 0.2366 - acc: 0.9382\n",
      "Epoch 7/10\n",
      "28312/28312 [==============================] - 3s 97us/step - loss: 0.2289 - acc: 0.9429\n",
      "Epoch 8/10\n",
      "28312/28312 [==============================] - 3s 98us/step - loss: 0.2225 - acc: 0.9459\n",
      "Epoch 9/10\n",
      "28312/28312 [==============================] - 3s 97us/step - loss: 0.2168 - acc: 0.9490\n",
      "Epoch 10/10\n",
      "28312/28312 [==============================] - 3s 99us/step - loss: 0.2122 - acc: 0.9502\n",
      "1000/1000 [==============================] - 0s 128us/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.6598332810401917, 0.762]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = build_model()\n",
    "with tf.device('/gpu:0'):\n",
    "    history = model.fit(x_train, y_train, epochs = 10, batch_size = 128)\n",
    "    y_pred = model.predict(x_test)\n",
    "    results = model.evaluate(x_test, y_test)\n",
    "results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1500x1000 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 500x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 500x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 500x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Normalized confusion matrix\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 500x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools\n",
    "import datetime\n",
    "\n",
    "now = datetime.datetime.now()\n",
    "pictures = []\n",
    "folder = \"FF\"\n",
    "\n",
    "def byte_to_mbti(byte):\n",
    "    binary = ''\n",
    "    for letter in byte:\n",
    "         binary +=(str(int(letter)))        \n",
    "    return type_dictionary[binary]\n",
    "\n",
    "decoded_y_true = [byte_to_mbti(label) for label in y_test.round()]\n",
    "decoded_y_pred = [byte_to_mbti(label) for label in y_pred.round()]\n",
    "\n",
    "matrix = confusion_matrix(decoded_y_true, decoded_y_pred, labels=type_labels)\n",
    "matrix_I_E = confusion_matrix(y_test[:,0], y_pred[:,0].round(), labels=[0, 1])\n",
    "matrix_N_S = confusion_matrix(y_test[:,1], y_pred[:,1].round(), labels=[0, 1])\n",
    "matrix_T_F = confusion_matrix(y_test[:,2], y_pred[:,2].round(), labels=[0, 1])\n",
    "matrix_J_P = confusion_matrix(y_test[:,3], y_pred[:,3].round(), labels=[0, 1])\n",
    "\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \"\"\"\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')\n",
    "    \n",
    "plt.figure(figsize=(15,10))\n",
    "plot_confusion_matrix(matrix, classes=type_labels, normalize=True,\n",
    "                      title='Confusion matrix')\n",
    "name = str(folder) + \"/\" + str(now.month) + \"-\" + str(now.day) + \"-\" + \\\n",
    "str(now.hour) + \"-\" + str(now.minute) + \"_\" + \"CM0.png\"\n",
    "plt.savefig(name)\n",
    "plt.show()\n",
    "pictures.append(name)\n",
    "\n",
    "plt.clf()\n",
    "plt.figure(figsize=(5,5))\n",
    "plot_confusion_matrix(matrix_I_E, classes=[\"I\", \"E\"], normalize=True,\n",
    "                      title='I-E Confusion matrix')\n",
    "name = str(folder) + \"/\" + str(now.month) + \"-\" + str(now.day) + \"-\" + \\\n",
    "str(now.hour) + \"-\" + str(now.minute) + \"_\" + \"CM1.png\"\n",
    "plt.savefig(name)\n",
    "plt.show()\n",
    "pictures.append(name)\n",
    "\n",
    "plt.clf()\n",
    "plt.figure(figsize=(5,5))\n",
    "plot_confusion_matrix(matrix_N_S, classes=[\"N\", \"S\"], normalize=True,\n",
    "                      title='N-S Confusion matrix')\n",
    "name = str(folder) + \"/\" + str(now.month) + \"-\" + str(now.day) + \"-\" + \\\n",
    "str(now.hour) + \"-\" + str(now.minute) + \"_\" + \"CM2.png\"\n",
    "plt.savefig(name)\n",
    "plt.show()\n",
    "pictures.append(name)\n",
    "\n",
    "plt.clf()\n",
    "plt.figure(figsize=(5,5))\n",
    "plot_confusion_matrix(matrix_T_F, classes=[\"T\", \"F\"], normalize=True,\n",
    "                      title='T-F Confusion matrix')\n",
    "name = str(folder) + \"/\" + str(now.month) + \"-\" + str(now.day) + \"-\" + \\\n",
    "str(now.hour) + \"-\" + str(now.minute) + \"_\" + \"CM3.png\"\n",
    "plt.savefig(name)\n",
    "plt.show()\n",
    "pictures.append(name)\n",
    "\n",
    "plt.clf()\n",
    "plt.figure(figsize=(5,5))\n",
    "plot_confusion_matrix(matrix_J_P, classes=[\"J\", \"P\"], normalize=True,\n",
    "                      title='J-P Confusion matrix')\n",
    "name = str(folder) + \"/\" + str(now.month) + \"-\" + str(now.day) + \"-\" + \\\n",
    "str(now.hour) + \"-\" + str(now.minute) + \"_\" + \"CM4.png\"\n",
    "plt.savefig(name)\n",
    "plt.show()\n",
    "pictures.append(name)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "model = build_model()\n",
    "with tf.device('/gpu:0'):\n",
    "    history = model.fit(x_partial_train, y_partial_train, epochs = 30, batch_size = 256, validation_data=(x_val, y_val))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "history_dict = history.history\n",
    "train_loss = history_dict['loss']\n",
    "val_loss = history_dict['val_loss']\n",
    "\n",
    "train_acc = history_dict['acc']\n",
    "val_acc   = history_dict['val_acc']\n",
    "\n",
    "epochs = range(1, len(history_dict['acc']) + 1)\n",
    "\n",
    "plt.plot(epochs, train_loss, 'bo', label='Training loss')\n",
    "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
    "plt.title('Training and validation loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()\n",
    "\n",
    "plt.clf()\n",
    "\n",
    "plt.plot(epochs, train_acc, 'bo', label='Training Accuracy')\n",
    "plt.plot(epochs, val_acc, 'b', label='Validation Accuracy')\n",
    "plt.title('Training and validation Accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#K-Fold Validation\n",
    "k = 4\n",
    "\n",
    "# // is floor div operator\n",
    "num_val_samples = len(x_train) // k\n",
    "\n",
    "k_val_loss = []\n",
    "k_val_acc = []\n",
    "\n",
    "for num_epochs in range(1, 20):\n",
    "    print(\"Epoch:\",num_epochs)\n",
    "    loss = []\n",
    "    acc = []\n",
    "    for i in range(k):\n",
    "        val_data = x_train[i * num_val_samples: (i + 1) * num_val_samples]\n",
    "        val_targets = y_train[i * num_val_samples: (i + 1) * num_val_samples]\n",
    "\n",
    "        partial_train_data = np.concatenate(\n",
    "            [x_train[:i * num_val_samples],\n",
    "             x_train[(i + 1) * num_val_samples:]],\n",
    "            axis=0)\n",
    "        partial_train_targets = np.concatenate(\n",
    "            [y_train[:i * num_val_samples],\n",
    "             y_train[(i + 1) * num_val_samples:]],\n",
    "            axis=0)\n",
    "\n",
    "        model = build_model()\n",
    "        with tf.device('/gpu:0'):\n",
    "            model.fit(partial_train_data, partial_train_targets,\n",
    "                epochs=num_epochs, batch_size=128,verbose = 0)\n",
    "\n",
    "            val_loss, val_acc = model.evaluate(val_data, val_targets, verbose = 0)\n",
    "\n",
    "        loss.append(val_loss)\n",
    "        acc.append(val_acc)\n",
    "        \n",
    "        del model\n",
    "        \n",
    "    k_val_loss.append(np.mean(loss))\n",
    "    k_val_acc.append(np.mean(acc))\n",
    "    print(str(k_val_loss[num_epochs - 1]), str(k_val_acc[num_epochs - 1]))"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "epochs = range(1, 21)\n",
    "\n",
    "plt.clf()\n",
    "\n",
    "plt.plot(epochs, k_val_acc, 'b', label='Validation Accuracy')\n",
    "plt.title('Validation Accuracy')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()\n",
    "\n",
    "plt.clf()\n",
    "\n",
    "\n",
    "plt.plot(epochs, k_val_loss, 'bo', label='Validation loss')\n",
    "plt.title('Validation loss')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss')\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myprint(s):\n",
    "    with open('results.log','a+') as f:\n",
    "        print(s, file=f)\n",
    "    f.close()\n",
    "        \n",
    "log_file = open('results.log', 'a+')\n",
    "\n",
    "log_file.write(\"\\n=================================================================\")\n",
    "log_file.write( \"\\n\" + str(now.month) + \"/\" + str(now.day) + \"/\" + str(now.year) + \" \" + \\\n",
    "str(now.hour) + \":\" + str(now.minute) + \":\" + str(now.second) + \"\\n\")\n",
    "\n",
    "log_file.close()\n",
    "\n",
    "model.summary(print_fn=myprint)\n",
    "\n",
    "log_file = open('results.log', 'a+')\n",
    "\n",
    "log_file.write(\"Results:\\t\" + str(results) + \"\\n\")\n",
    "\n",
    "log_file.write(\"Images:\\n\")\n",
    "log_file.write(\"\\t\" + pictures[0] + \"\\n\")\n",
    "log_file.write(\"\\t\" + pictures[1] + \"\\n\")\n",
    "log_file.write(\"\\t\" + pictures[2] + \"\\n\")\n",
    "log_file.write(\"\\t\" + pictures[3] + \"\\n\")\n",
    "log_file.write(\"\\t\" + pictures[4] + \"\\n\")\n",
    "\n",
    "log_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'ISFJ': 1832,\n",
       "         'INFJ': 1832,\n",
       "         'INFP': 1832,\n",
       "         'INTJ': 1832,\n",
       "         'ISTP': 1832,\n",
       "         'ESTP': 1832,\n",
       "         'INTP': 1832,\n",
       "         'ESFP': 1832,\n",
       "         'ISTJ': 1832,\n",
       "         'ENTP': 1832,\n",
       "         'ENFP': 1832,\n",
       "         'ENTJ': 1832,\n",
       "         'ESTJ': 1832,\n",
       "         'ISFP': 1832,\n",
       "         'ENFJ': 1832,\n",
       "         'ESFJ': 1832})"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counts = Counter(types)\n",
    "counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "URE18",
   "language": "python",
   "name": "ure18"
  },
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}