vectorizer/8.auto-encoder.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",
      "/usr/local/lib/python3.5/dist-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "import sklearn.datasets\n",
    "from sklearn.cross_validation import train_test_split\n",
    "import re\n",
    "import tensorflow as tf\n",
    "from sklearn import metrics\n",
    "import numpy as np\n",
    "import collections\n",
    "import time\n",
    "import os\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clearstring(string):\n",
    "    string = re.sub('[^A-Za-z ]+', '', string)\n",
    "    string = string.split('\\n')\n",
    "    string = [y.strip() for y in filter(None, string)]\n",
    "    string = (' '.join(string)).lower()\n",
    "    return ' '.join([y.strip() for y in string.split()])\n",
    "\n",
    "def separate_dataset(trainset):\n",
    "    datastring = []\n",
    "    datatarget = []\n",
    "    for i in range(len(trainset.data)):\n",
    "        data_ = trainset.data[i].split('\\n')\n",
    "        data_ = list(filter(None, data_))\n",
    "        for n in range(len(data_)):\n",
    "            data_[n] = clearstring(data_[n])\n",
    "        datastring += data_\n",
    "        for n in range(len(data_)):\n",
    "            datatarget.append(trainset.target[i])\n",
    "    return datastring, datatarget\n",
    "\n",
    "def build_dataset(words, n_words):\n",
    "    count = [['GO', 0], ['PAD', 1], ['EOS', 2], ['UNK', 3]]\n",
    "    count.extend(collections.Counter(words).most_common(n_words))\n",
    "    dictionary = dict()\n",
    "    for word, _ in count:\n",
    "        dictionary[word] = len(dictionary)\n",
    "    data = list()\n",
    "    unk_count = 0\n",
    "    for word in words:\n",
    "        index = dictionary.get(word, 0)\n",
    "        if index == 0:\n",
    "            unk_count += 1\n",
    "        data.append(index)\n",
    "    count[0][1] = unk_count\n",
    "    reversed_dictionary = dict(zip(dictionary.values(), dictionary.keys()))\n",
    "    return data, count, dictionary, reversed_dictionary\n",
    "\n",
    "def str_idx(corpus, dic, maxlen, UNK=3):\n",
    "    X = np.zeros((len(corpus),maxlen))\n",
    "    for i in range(len(corpus)):\n",
    "        for no, k in enumerate(corpus[i].split()[:maxlen][::-1]):\n",
    "            try:\n",
    "                X[i,-1 - no]=dic[k]\n",
    "            except Exception as e:\n",
    "                X[i,-1 - no]=UNK\n",
    "    return X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "320"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset = sklearn.datasets.load_files(container_path = 'data', encoding = 'UTF-8')\n",
    "dataset.data, dataset.target = separate_dataset(dataset)\n",
    "_,dataset.data,_,dataset.target=train_test_split(dataset.data,dataset.target,test_size = 0.03)\n",
    "len(dataset.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vocab from size: 2392\n",
      "Most common words [('the', 321), ('a', 212), ('and', 194), ('of', 177), ('to', 146), ('is', 100)]\n",
      "Sample data [1632, 9, 17, 1947, 7, 887, 36, 7, 4, 121] ['eastwood', 'is', 'an', 'icon', 'of', 'moviemaking', 'one', 'of', 'the', 'best']\n"
     ]
    }
   ],
   "source": [
    "concat = ' '.join(dataset.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": [
    "GO = dictionary['GO']\n",
    "PAD = dictionary['PAD']\n",
    "EOS = dictionary['EOS']\n",
    "UNK = dictionary['UNK']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model:\n",
    "    def __init__(self, size_layer, num_layers, embedded_size,\n",
    "                 dict_size, dimension_output, learning_rate,seq_len):\n",
    "        def cells(size,reuse=False):\n",
    "            return tf.nn.rnn_cell.LSTMCell(size,initializer=tf.orthogonal_initializer(),reuse=reuse)\n",
    "        self.X = tf.placeholder(tf.int32, [None, None])\n",
    "        encoder_embeddings = tf.Variable(tf.random_uniform([dict_size, embedded_size], 0, 1))\n",
    "        encoder_embedded = tf.nn.embedding_lookup(encoder_embeddings, self.X)\n",
    "        rnn_cells = tf.nn.rnn_cell.MultiRNNCell([cells(size_layer) for _ in range(num_layers)])\n",
    "        outputs, _ = tf.nn.dynamic_rnn(rnn_cells, encoder_embedded, dtype = tf.float32)\n",
    "        outputs = tf.reshape(outputs,[-1,seq_len*size_layer])\n",
    "        W = tf.get_variable('w',shape=(size_layer*seq_len, dimension_output),initializer=tf.orthogonal_initializer())\n",
    "        b = tf.get_variable('b',shape=(dimension_output),initializer=tf.zeros_initializer())\n",
    "        self.logits = tf.nn.tanh(tf.matmul(outputs, W) + b)\n",
    "        W_decoder = tf.get_variable('w_decoder',shape=(dimension_output,size_layer*seq_len),initializer=tf.orthogonal_initializer())\n",
    "        b_decoder = tf.get_variable('b_decoder',shape=(size_layer*seq_len),initializer=tf.zeros_initializer())\n",
    "        logits_decoder = tf.nn.tanh(tf.matmul(self.logits,W_decoder) + b_decoder)\n",
    "        logits_decoder = tf.reshape(logits_decoder,[-1,seq_len,size_layer])\n",
    "        with tf.variable_scope(\"decoder\"):\n",
    "            rnn_cells_decoder = tf.nn.rnn_cell.MultiRNNCell([cells(embedded_size) for _ in range(num_layers)])\n",
    "            outputs, _ = tf.nn.dynamic_rnn(rnn_cells_decoder, logits_decoder, dtype = tf.float32)\n",
    "        decoder_dense = tf.layers.dense(outputs,dict_size)\n",
    "        onehot_X = tf.one_hot(self.X,dict_size,axis=2,dtype=tf.float32)\n",
    "        loss=tf.nn.softmax_cross_entropy_with_logits(labels = onehot_X, logits = decoder_dense)\n",
    "        self.cost = tf.reduce_mean(loss)\n",
    "        self.optimizer = tf.train.RMSPropOptimizer(learning_rate).minimize(self.cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "size_layer = 256\n",
    "num_layers = 2\n",
    "embedded_size = 128\n",
    "dimension_output = 100\n",
    "learning_rate = 1e-2\n",
    "maxlen = 50\n",
    "batch_size = 32\n",
    "epoch = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf.reset_default_graph()\n",
    "sess = tf.InteractiveSession()\n",
    "model = Model(size_layer,num_layers,embedded_size,vocabulary_size+4,dimension_output,learning_rate,maxlen)\n",
    "sess.run(tf.global_variables_initializer())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = str_idx(dataset.data,dictionary,maxlen)\n",
    "Y = dataset.target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1, avg loss 7.760394\n",
      "epoch 2, avg loss 7.704803\n",
      "epoch 3, avg loss 7.635571\n",
      "epoch 4, avg loss 7.540095\n",
      "epoch 5, avg loss 7.259135\n",
      "epoch 6, avg loss 5.018867\n",
      "epoch 7, avg loss 4.009128\n",
      "epoch 8, avg loss 3.605722\n",
      "epoch 9, avg loss 3.323606\n",
      "epoch 10, avg loss 3.199110\n"
     ]
    }
   ],
   "source": [
    "for i in range(epoch):\n",
    "    total_loss = 0\n",
    "    for k in range(0, (X.shape[0]//batch_size)*batch_size,batch_size):\n",
    "        loss,_ = sess.run([model.cost,model.optimizer],feed_dict={model.X:X[k:k+batch_size,:]})\n",
    "        total_loss += loss\n",
    "    total_loss /= (X.shape[0]//batch_size)\n",
    "    print('epoch %d, avg loss %f'%(i+1,total_loss))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(320, 100)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logits_test = sess.run(tf.nn.sigmoid(model.logits),feed_dict={model.X:X})\n",
    "logits_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.7244937 , 0.71604526, 0.2728961 , ..., 0.7290659 , 0.6692666 ,\n",
       "        0.7200828 ],\n",
       "       [0.72441274, 0.7157007 , 0.27314687, ..., 0.7290498 , 0.66894525,\n",
       "        0.72017443],\n",
       "       [0.7248277 , 0.71632665, 0.27279508, ..., 0.7290951 , 0.6697026 ,\n",
       "        0.720635  ],\n",
       "       ...,\n",
       "       [0.72442067, 0.71599936, 0.27315977, ..., 0.72899246, 0.6683353 ,\n",
       "        0.72006834],\n",
       "       [0.7250132 , 0.7173392 , 0.2725796 , ..., 0.7291803 , 0.6708015 ,\n",
       "        0.72104675],\n",
       "       [0.7243585 , 0.71537685, 0.27310753, ..., 0.728969  , 0.6686277 ,\n",
       "        0.7199703 ]], dtype=float32)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logits_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.manifold import TSNE\n",
    "manifold_polarity = TSNE(n_components=2).fit_transform(logits_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set()\n",
    "from matplotlib import offsetbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f466da6b588>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax_min = np.min(logits_test,0)\n",
    "ax_max = np.max(logits_test,0)\n",
    "ax_dist_sq = np.sum((ax_max-ax_min)**2)\n",
    "plt.figure(figsize=(11,11))\n",
    "ax = plt.subplot(111)\n",
    "shown_images = np.array([[1., 1.]])\n",
    "colors = sns.color_palette(n_colors=len(dataset.target_names))\n",
    "for i in range(manifold_polarity.shape[0]):\n",
    "    dist = np.sum((manifold_polarity[i] - shown_images)**2, 1)\n",
    "    if np.min(dist) < 3e-4*ax_dist_sq:\n",
    "        continue\n",
    "    shown_images = np.r_[shown_images, [manifold_polarity[i]]]\n",
    "    plt.scatter(manifold_polarity[i,0],manifold_polarity[i,1],c=colors[Y[i]])\n",
    "plt.legend(dataset.target_names)\n",
    "plt.show()"
   ]
  },
  {
   "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
}