text-classification/52.fast-text.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.5/dist-packages/sklearn/cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.\n",
      "  \"This module will be removed in 0.20.\", DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from utils import *\n",
    "import tensorflow as tf\n",
    "from sklearn.cross_validation import train_test_split\n",
    "import time\n",
    "from tqdm import tqdm\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "ngram_range = 2\n",
    "max_features = 20000\n",
    "maxlen = 50\n",
    "batch_size = 64\n",
    "embedded_size = 128\n",
    "epoch = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['negative', 'positive']\n",
      "10662\n",
      "10662\n"
     ]
    }
   ],
   "source": [
    "trainset = sklearn.datasets.load_files(container_path = 'data', encoding = 'UTF-8')\n",
    "trainset.data, trainset.target = separate_dataset(trainset,1.0)\n",
    "print (trainset.target_names)\n",
    "print (len(trainset.data))\n",
    "print (len(trainset.target))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vocab from size: 20332\n",
      "Most common words [('film', 1453), ('movie', 1270), ('one', 727), ('like', 721), ('story', 477), ('much', 386)]\n",
      "Sample data [534, 2516, 3188, 18774, 36, 7790, 219, 150, 19, 4274] ['rock', 'destined', '21st', 'centurys', 'new', 'conan', 'hes', 'going', 'make', 'splash']\n"
     ]
    }
   ],
   "source": [
    "concat = ' '.join(trainset.data).split()\n",
    "vocabulary_size = len(list(set(concat)))\n",
    "data, count, dictionary, rev_dictionary = build_dataset(concat, vocabulary_size)\n",
    "print('vocab from size: %d'%(vocabulary_size))\n",
    "print('Most common words', count[4:10])\n",
    "print('Sample data', data[:10], [rev_dictionary[i] for i in data[:10]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "idx_trainset = []\n",
    "for text in trainset.data:\n",
    "    idx = []\n",
    "    for t in text.split():\n",
    "        try:\n",
    "            idx.append(dictionary[t])\n",
    "        except:\n",
    "            pass\n",
    "    idx_trainset.append(idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_ngram_set(input_list, ngram_value):\n",
    "    return set(zip(*[input_list[i:] for i in range(ngram_value)]))\n",
    "\n",
    "def build_ngram(x_train):\n",
    "    global max_features\n",
    "    ngram_set = set()\n",
    "    for input_list in tqdm(x_train, total=len(x_train), ncols=70):\n",
    "        for i in range(2, ngram_range + 1):\n",
    "            set_of_ngram = create_ngram_set(input_list, ngram_value=i)\n",
    "            ngram_set.update(set_of_ngram)\n",
    "    start_index = max_features + 1\n",
    "    token_indice = {v: k + start_index for k, v in enumerate(ngram_set)}\n",
    "    indice_token = {token_indice[k]: k for k in token_indice}\n",
    "\n",
    "    max_features = np.max(list(indice_token.keys())) + 1\n",
    "    return token_indice\n",
    "\n",
    "def add_ngram(sequences, token_indice):\n",
    "    new_sequences = []\n",
    "    for input_list in tqdm(sequences, total=len(sequences), ncols=70):\n",
    "        new_list = input_list[:]\n",
    "        for ngram_value in range(2, ngram_range + 1):\n",
    "            for i in range(len(new_list) - ngram_value + 1):\n",
    "                ngram = tuple(new_list[i:i + ngram_value])\n",
    "                if ngram in token_indice:\n",
    "                    new_list.append(token_indice[ngram])\n",
    "        new_sequences.append(new_list)\n",
    "    return new_sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████| 10662/10662 [00:00<00:00, 261904.50it/s]\n",
      "100%|████████████████████████| 10662/10662 [00:00<00:00, 64394.97it/s]\n"
     ]
    }
   ],
   "source": [
    "token_indice = build_ngram(idx_trainset)\n",
    "X = add_ngram(idx_trainset, token_indice)\n",
    "X = tf.keras.preprocessing.sequence.pad_sequences(X, maxlen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10662, 50)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_X, test_X, train_Y, test_Y = train_test_split(X, \n",
    "                                                    trainset.target,\n",
    "                                                    test_size = 0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model:\n",
    "    def __init__(self, embedded_size, dict_size, dimension_output, learning_rate):\n",
    "        \n",
    "        self.X = tf.placeholder(tf.int32, [None, None])\n",
    "        self.Y = tf.placeholder(tf.int32, [None])\n",
    "        encoder_embeddings = tf.Variable(tf.random_uniform([dict_size, embedded_size], -1, 1))\n",
    "        encoder_embedded = tf.nn.embedding_lookup(encoder_embeddings, self.X)\n",
    "        self.logits = tf.layers.dense(tf.reduce_mean(encoder_embedded, 1), dimension_output)\n",
    "        self.cost = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(\n",
    "            logits=self.logits,\n",
    "            labels=self.Y))\n",
    "        self.optimizer = tf.train.AdamOptimizer(learning_rate).minimize(self.cost)\n",
    "        correct_pred = tf.equal(tf.argmax(self.logits, 1,output_type=tf.int32), self.Y)\n",
    "        self.accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.reset_default_graph()\n",
    "sess = tf.InteractiveSession()\n",
    "model = Model(embedded_size,vocabulary_size+4,2,1e-3)\n",
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 0, pass acc: 0.000000, current acc: 0.533144\n",
      "time taken: 0.6158695220947266\n",
      "epoch: 0, training loss: 0.691755, training acc: 0.522791, valid loss: 0.686008, valid acc: 0.533144\n",
      "\n",
      "epoch: 1, pass acc: 0.533144, current acc: 0.579545\n",
      "time taken: 0.5032393932342529\n",
      "epoch: 1, training loss: 0.674360, training acc: 0.606438, valid loss: 0.673455, valid acc: 0.579545\n",
      "\n",
      "epoch: 2, pass acc: 0.579545, current acc: 0.625947\n",
      "time taken: 0.49947619438171387\n",
      "epoch: 2, training loss: 0.650408, training acc: 0.687970, valid loss: 0.656426, valid acc: 0.625947\n",
      "\n",
      "epoch: 3, pass acc: 0.625947, current acc: 0.665720\n",
      "time taken: 0.4993126392364502\n",
      "epoch: 3, training loss: 0.614892, training acc: 0.760221, valid loss: 0.632600, valid acc: 0.665720\n",
      "\n",
      "epoch: 4, pass acc: 0.665720, current acc: 0.693182\n",
      "time taken: 0.49781179428100586\n",
      "epoch: 4, training loss: 0.566665, training acc: 0.811560, valid loss: 0.603644, valid acc: 0.693182\n",
      "\n",
      "epoch: 5, pass acc: 0.693182, current acc: 0.721591\n",
      "time taken: 0.49106740951538086\n",
      "epoch: 5, training loss: 0.511118, training acc: 0.845512, valid loss: 0.574397, valid acc: 0.721591\n",
      "\n",
      "epoch: 6, pass acc: 0.721591, current acc: 0.737689\n",
      "time taken: 0.49951720237731934\n",
      "epoch: 6, training loss: 0.455711, training acc: 0.867834, valid loss: 0.549181, valid acc: 0.737689\n",
      "\n",
      "epoch: 7, pass acc: 0.737689, current acc: 0.744318\n",
      "time taken: 0.5063953399658203\n",
      "epoch: 7, training loss: 0.405183, training acc: 0.887923, valid loss: 0.529742, valid acc: 0.744318\n",
      "\n",
      "epoch: 8, pass acc: 0.744318, current acc: 0.750473\n",
      "time taken: 0.494675874710083\n",
      "epoch: 8, training loss: 0.361051, training acc: 0.904018, valid loss: 0.515914, valid acc: 0.750473\n",
      "\n",
      "epoch: 9, pass acc: 0.750473, current acc: 0.754261\n",
      "time taken: 0.49280738830566406\n",
      "epoch: 9, training loss: 0.323087, training acc: 0.916001, valid loss: 0.506813, valid acc: 0.754261\n",
      "\n",
      "epoch: 10, pass acc: 0.754261, current acc: 0.757576\n",
      "time taken: 0.4900953769683838\n",
      "epoch: 10, training loss: 0.290481, training acc: 0.927044, valid loss: 0.501482, valid acc: 0.757576\n",
      "\n",
      "epoch: 11, pass acc: 0.757576, current acc: 0.759470\n",
      "time taken: 0.5003037452697754\n",
      "epoch: 11, training loss: 0.262356, training acc: 0.935268, valid loss: 0.499107, valid acc: 0.759470\n",
      "\n",
      "epoch: 12, pass acc: 0.759470, current acc: 0.760890\n",
      "time taken: 0.4879310131072998\n",
      "epoch: 12, training loss: 0.237943, training acc: 0.942669, valid loss: 0.499046, valid acc: 0.760890\n",
      "\n",
      "epoch: 13, pass acc: 0.760890, current acc: 0.762311\n",
      "time taken: 0.49901485443115234\n",
      "epoch: 13, training loss: 0.216611, training acc: 0.948073, valid loss: 0.500812, valid acc: 0.762311\n",
      "\n",
      "epoch: 14, pass acc: 0.762311, current acc: 0.764205\n",
      "time taken: 0.5128223896026611\n",
      "epoch: 14, training loss: 0.197850, training acc: 0.954065, valid loss: 0.504037, valid acc: 0.764205\n",
      "\n",
      "epoch: 15, pass acc: 0.764205, current acc: 0.765625\n",
      "time taken: 0.4926328659057617\n",
      "epoch: 15, training loss: 0.181254, training acc: 0.958059, valid loss: 0.508442, valid acc: 0.765625\n",
      "\n",
      "epoch: 16, pass acc: 0.765625, current acc: 0.767045\n",
      "time taken: 0.48828673362731934\n",
      "epoch: 16, training loss: 0.166496, training acc: 0.961349, valid loss: 0.513818, valid acc: 0.767045\n",
      "\n",
      "time taken: 0.5014266967773438\n",
      "epoch: 17, training loss: 0.153308, training acc: 0.965461, valid loss: 0.520006, valid acc: 0.764678\n",
      "\n",
      "time taken: 0.4906783103942871\n",
      "epoch: 18, training loss: 0.141474, training acc: 0.968985, valid loss: 0.526883, valid acc: 0.763258\n",
      "\n",
      "time taken: 0.5114943981170654\n",
      "epoch: 19, training loss: 0.130813, training acc: 0.972039, valid loss: 0.534357, valid acc: 0.762311\n",
      "\n",
      "time taken: 0.4888913631439209\n",
      "epoch: 20, training loss: 0.121176, training acc: 0.974977, valid loss: 0.542355, valid acc: 0.761837\n",
      "\n",
      "time taken: 0.4949989318847656\n",
      "epoch: 21, training loss: 0.112436, training acc: 0.977796, valid loss: 0.550823, valid acc: 0.757576\n",
      "\n",
      "break epoch:22\n",
      "\n"
     ]
    }
   ],
   "source": [
    "EARLY_STOPPING, CURRENT_CHECKPOINT, CURRENT_ACC, EPOCH = 5, 0, 0, 0\n",
    "while True:\n",
    "    lasttime = time.time()\n",
    "    if CURRENT_CHECKPOINT == EARLY_STOPPING:\n",
    "        print('break epoch:%d\\n'%(EPOCH))\n",
    "        break\n",
    "        \n",
    "    train_acc, train_loss, test_acc, test_loss = 0, 0, 0, 0\n",
    "    for i in range(0, (len(train_X) // batch_size) * batch_size, batch_size):\n",
    "        acc, loss, _ = sess.run([model.accuracy, model.cost, model.optimizer], \n",
    "                           feed_dict = {model.X : train_X[i:i+batch_size], model.Y : train_Y[i:i+batch_size]})\n",
    "        train_loss += loss\n",
    "        train_acc += acc\n",
    "    \n",
    "    for i in range(0, (len(test_X) // batch_size) * batch_size, batch_size):\n",
    "        acc, loss = sess.run([model.accuracy, model.cost], \n",
    "                           feed_dict = {model.X : test_X[i:i+batch_size], model.Y : test_Y[i:i+batch_size]})\n",
    "        test_loss += loss\n",
    "        test_acc += acc\n",
    "    \n",
    "    train_loss /= (len(train_X) // batch_size)\n",
    "    train_acc /= (len(train_X) // batch_size)\n",
    "    test_loss /= (len(test_X) // batch_size)\n",
    "    test_acc /= (len(test_X) // batch_size)\n",
    "    \n",
    "    if test_acc > CURRENT_ACC:\n",
    "        print('epoch: %d, pass acc: %f, current acc: %f'%(EPOCH,CURRENT_ACC, test_acc))\n",
    "        CURRENT_ACC = test_acc\n",
    "        CURRENT_CHECKPOINT = 0\n",
    "    else:\n",
    "        CURRENT_CHECKPOINT += 1\n",
    "        \n",
    "    print('time taken:', time.time()-lasttime)\n",
    "    print('epoch: %d, training loss: %f, training acc: %f, valid loss: %f, valid acc: %f\\n'%(EPOCH,train_loss,\n",
    "                                                                                          train_acc,test_loss,\n",
    "                                                                                          test_acc))\n",
    "    EPOCH += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision    recall  f1-score   support\n",
      "\n",
      "   negative       0.76      0.75      0.76      1060\n",
      "   positive       0.76      0.76      0.76      1073\n",
      "\n",
      "avg / total       0.76      0.76      0.76      2133\n",
      "\n"
     ]
    }
   ],
   "source": [
    "logits = sess.run(model.logits, feed_dict={model.X:test_X})\n",
    "print(metrics.classification_report(test_Y, np.argmax(logits,1), target_names = trainset.target_names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}