base_ctc-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "curves = pickle.load(open('curves.pkl', 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "for row in curves:\n",
    "    x = np.array(row['curve']['x']) / 100.\n",
    "    y = np.array(row['curve']['y']) / 100.\n",
    "    dx = np.concatenate([[0], np.diff(row['curve']['x'])], 0) / 10.\n",
    "    dy = np.concatenate([[0], np.diff(row['curve']['y'])], 0) / 10.\n",
    "    dt = np.concatenate([[0], np.diff(row['curve']['t'])], 0) / 10.\n",
    "    \n",
    "    row['curve_features'] = np.stack([x, y, dx, dy, dt], -1)\n",
    "    \n",
    "    row['curve']['dt'] = dt\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jheuristic/.local/lib/python3.5/site-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": [
    "from sklearn.cross_validation import train_test_split\n",
    "train_curves, val_curves = train_test_split(curves, test_size=0.1, random_state=42)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "лесная\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x7f80973cda58>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f80993e5668>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "i=10\n",
    "curve = curves[i]['curve']\n",
    "print(curves[i]['word'])\n",
    "\n",
    "plt.plot(curve['x'], curve['y'])\n",
    "plt.scatter(curve['x'], curve['y'], \n",
    "             s=curve['dt'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_tokens = 38\n"
     ]
    }
   ],
   "source": [
    "tokens = sorted(list(set(' '.join(curve['word'] for curve in curves))))\n",
    "\n",
    "EOS = ';'\n",
    "assert EOS not in tokens\n",
    "tokens = [None, EOS] + tokens + [None] #make sure EOS is 1-st to make it tfnn-familiar\n",
    "\n",
    "\n",
    "token_to_id = {t:i for i, t in enumerate(tokens)}\n",
    "print(\"n_tokens =\", len(tokens))\n",
    "\n",
    "EOS_ix = token_to_id[EOS]\n",
    "BLANK_ix = len(tokens) - 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_matrix(lines, max_len=None,  dtype='int32', batch_first = True):\n",
    "    \"\"\"Casts a list of names into rnn-digestable matrix\"\"\"\n",
    "    \n",
    "    max_len = max_len or (max(map(len, lines)) + 1)\n",
    "    lines_ix = np.full([len(lines), max_len], EOS_ix, dtype=dtype)\n",
    "\n",
    "    for i in range(len(lines)):\n",
    "        line_ix = [token_to_id[c] for c in lines[i]]\n",
    "        line_ix.append(EOS_ix)\n",
    "        lines_ix[i, :len(line_ix)] = line_ix\n",
    "        \n",
    "    if not batch_first: # convert [batch, time] into [time, batch]\n",
    "        lines_ix = np.transpose(lines_ix)\n",
    "\n",
    "    return lines_ix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['этапах', 'ориентацию', 'атс', 'боится', 'глядеть']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[33, 22,  4, 19,  4, 25,  1,  1,  1,  1,  1],\n",
       "       [18, 20, 12,  9, 17, 22,  4, 26, 12, 34,  1],\n",
       "       [ 4, 22, 21,  1,  1,  1,  1,  1,  1,  1,  1],\n",
       "       [ 5, 18, 12, 22, 21, 35,  1,  1,  1,  1,  1],\n",
       "       [ 7, 15, 35,  8,  9, 22, 32,  1,  1,  1,  1]], dtype=int32)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_dummy_curves = [x['word'] for x in train_curves[:5]]\n",
    "print(_dummy_curves)\n",
    "to_matrix(_dummy_curves)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "NUM_FEATURES = row['curve_features'].shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "curve_to_array = lambda curve: np.stack([curve[c] for c in curve_features], -1)\n",
    "\n",
    "def generate_batch(curves, batch_size=None, replace=False):\n",
    "    if batch_size is not None:\n",
    "        curves = [curves[i] for i in np.random.choice(len(curves), batch_size, replace=replace)]\n",
    "        \n",
    "    words = [x['word'] for x in curves]\n",
    "    \n",
    "    words_ix = to_matrix(words)\n",
    "    features = [x['curve_features'] for x in curves]\n",
    "    swipe_lengths = np.array(list(map(len, features)), dtype='int32')\n",
    "    \n",
    "    features_matrix = np.zeros([len(features), max(swipe_lengths), NUM_FEATURES], 'float32')\n",
    "    for i, swipe in enumerate(features):\n",
    "        features_matrix[i, :len(swipe)] = swipe\n",
    "    \n",
    "    return features_matrix, swipe_lengths, words_ix\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "_dummy_swipe, _dummy_swipe_len, _dummy_target_ix = generate_batch(train_curves, batch_size=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: CUDA_VISIBLE_DEVICES=1\n"
     ]
    }
   ],
   "source": [
    "%env CUDA_VISIBLE_DEVICES=1\n",
    "import tensorflow as tf\n",
    "tf.reset_default_graph()\n",
    "gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.45, allow_growth=True)\n",
    "sess = tf.InteractiveSession(config=tf.ConfigProto(gpu_options=gpu_options, \n",
    "                                                   allow_soft_placement=True,\n",
    "                                                   log_device_placement=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tfnn.ops.basic import infer_length\n",
    "swipe_ph = tf.placeholder_with_default(_dummy_swipe, [None, None, NUM_FEATURES])\n",
    "swipe_len_ph = tf.placeholder_with_default(_dummy_swipe_len, [None])\n",
    "reference_answers = tf.placeholder_with_default(_dummy_target_ix, [None, None])\n",
    "\n",
    "swipe_mask = tf.sequence_mask(swipe_len_ph, maxlen=tf.shape(swipe_ph)[1], dtype=tf.float32)\n",
    "ref_len = infer_length(reference_answers, EOS_ix)\n",
    "ref_mask = tf.sequence_mask(ref_len, maxlen=tf.shape(reference_answers)[1], dtype=tf.float32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import keras\n",
    "from keras.models import Sequential\n",
    "import keras.layers as L\n",
    "keras.backend.set_session(sess)\n",
    "\n",
    "model = Sequential([\n",
    "    L.InputLayer((None, NUM_FEATURES)),\n",
    "    L.GRU(256, return_sequences=True),\n",
    "    L.Dense(len(tokens))\n",
    "])\n",
    "\n",
    "logits = model(swipe_ph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tfnn.ops.basic import infer_mask\n",
    "\n",
    "\n",
    "def compute_ctc_loss(logits, logits_length, out_ref, eos_ix=1,\n",
    "                     force_blanks_after_eos=True):\n",
    "    \"\"\"\n",
    "    Computes CTC loss function for each sequence in batch\n",
    "    :param logits: translation logits, tensor float32[batch, time, voc_size]\n",
    "    :param logits_length: logit sequence lengths, tensor int[batch]\n",
    "    :param eos_ix: id of end-of-sequence. MAKE SURE IT IS CORRECT\n",
    "    :param force_blanks_after_eos: if True, forces blanks\n",
    "    :returns: differentiable CTC loss, float32[batch_size]\n",
    "    \"\"\"\n",
    "    assert logits.shape[-1] is not None\n",
    "\n",
    "    # blank is now the last token\n",
    "    blank_index = tf.cast(logits.shape[-1], out_ref.dtype)\n",
    "\n",
    "    if force_blanks_after_eos:\n",
    "        # make sure reference labels after first EOS are blanks\n",
    "        out_mask = infer_mask(out_ref, eos_ix, dtype=out_ref.dtype)\n",
    "        out_ref = out_ref * out_mask + tf.fill(tf.shape(out_ref), blank_index) * (1 - out_mask)\n",
    "    # cast labels to sparse\n",
    "    # [0,0], [0,1], ..., [1,0], [1,1], ... [batch_size, max_length]\n",
    "    out_ref_indices = tf.where(infer_mask(out_ref, eos_ix))\n",
    "    out_ref_values = tf.gather_nd(out_ref, out_ref_indices)\n",
    "    out_ref_sparse = tf.SparseTensor(out_ref_indices, out_ref_values,\n",
    "                                     dense_shape=tf.cast(tf.shape(out_ref), 'int64'))\n",
    "\n",
    "    out_ref_sparse = tf.cast(out_ref_sparse, dtype='int32')\n",
    "\n",
    "    return tf.nn.ctc_loss(labels=out_ref_sparse,\n",
    "                          inputs=logits,\n",
    "                          sequence_length=logits_length,\n",
    "                          preprocess_collapse_repeated=False,\n",
    "                          ctc_merge_repeated=True,\n",
    "                          time_major=False, )\n",
    "\n",
    "\n",
    "def translate(logits, logits_length,pad_ix=1,\n",
    "              decoder=tf.nn.ctc_greedy_decoder, **kwargs):\n",
    "    \"\"\"\n",
    "    Infers output sequence from logits trained with ctc loss\n",
    "    :param logits: translation logits, tensor float32[batch, time, voc_size]\n",
    "    :param logits_length: logit sequence lengths, tensor int[batch]\n",
    "    :param pad_ix: pads with this value after sequence end\n",
    "    :param decoder: tf.nn.ctc_greedy_decoder, tf.nn.ctc_beam_search_decoder or similar function.\n",
    "        Used as decoder(logits_time_major, logits_length, merge_repeated, **kwargs)[0][0]\n",
    "    :param kwargs: any parameters passed to decoder\n",
    "    :return: sequence of translation token ids, int[batch, time]\n",
    "    \"\"\"\n",
    "\n",
    "    logits_time_major = tf.transpose(logits, [1, 0, 2])\n",
    "\n",
    "    # sparse int [batch, time]\n",
    "    trans_sparse = decoder(\n",
    "                         logits_time_major,\n",
    "                         logits_length,\n",
    "                         merge_repeated=True,\n",
    "                         **kwargs)[0][0]\n",
    "\n",
    "    trans = tf.sparse_tensor_to_dense(trans_sparse, default_value=pad_ix)\n",
    "    return trans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = compute_ctc_loss(logits, swipe_len_ph, reference_answers, eos_ix=EOS_ix)\n",
    "loss = tf.reduce_mean(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "step = tf.train.AdamOptimizer(learning_rate=1e-4).minimize(loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import clear_output\n",
    "import pandas as pd\n",
    "ewma = lambda x, span=10: pd.ewma(np.asarray(x), span=span)\n",
    "history = []\n",
    "sess.run(tf.global_variables_initializer())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f7f1cbbcf98>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31.751144\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f7f1cbd1e48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 397/1000000 [07:55<332:36:45,  1.20s/it]"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-0f49d31d186a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m                             generate_batch(train_curves, batch_size=128),))\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m     \u001b[0mloss_t\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msess\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstep\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m     \u001b[0mhistory\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss_t\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.5/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(self, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m    887\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    888\u001b[0m       result = self._run(None, fetches, feed_dict, options_ptr,\n\u001b[0;32m--> 889\u001b[0;31m                          run_metadata_ptr)\n\u001b[0m\u001b[1;32m    890\u001b[0m       \u001b[0;32mif\u001b[0m \u001b[0mrun_metadata\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    891\u001b[0m         \u001b[0mproto_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_session\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTF_GetBuffer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_metadata_ptr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.5/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run\u001b[0;34m(self, handle, fetches, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1118\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mfinal_fetches\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mfinal_targets\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mhandle\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mfeed_dict_tensor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1119\u001b[0m       results = self._do_run(handle, final_targets, final_fetches,\n\u001b[0;32m-> 1120\u001b[0;31m                              feed_dict_tensor, options, run_metadata)\n\u001b[0m\u001b[1;32m   1121\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1122\u001b[0m       \u001b[0mresults\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.5/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_do_run\u001b[0;34m(self, handle, target_list, fetch_list, feed_dict, options, run_metadata)\u001b[0m\n\u001b[1;32m   1315\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mhandle\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1316\u001b[0m       return self._do_call(_run_fn, self._session, feeds, fetches, targets,\n\u001b[0;32m-> 1317\u001b[0;31m                            options, run_metadata)\n\u001b[0m\u001b[1;32m   1318\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1319\u001b[0m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_do_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_prun_fn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_session\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhandle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeeds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfetches\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.5/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_do_call\u001b[0;34m(self, fn, *args)\u001b[0m\n\u001b[1;32m   1321\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_do_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1322\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1323\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1324\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mOpError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1325\u001b[0m       \u001b[0mmessage\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcompat\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_text\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmessage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/.local/lib/python3.5/site-packages/tensorflow/python/client/session.py\u001b[0m in \u001b[0;36m_run_fn\u001b[0;34m(session, feed_dict, fetch_list, target_list, options, run_metadata)\u001b[0m\n\u001b[1;32m   1300\u001b[0m           return tf_session.TF_Run(session, options,\n\u001b[1;32m   1301\u001b[0m                                    \u001b[0mfeed_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfetch_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtarget_list\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1302\u001b[0;31m                                    status, run_metadata)\n\u001b[0m\u001b[1;32m   1303\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1304\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_prun_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msession\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhandle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfetch_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "from tqdm import trange\n",
    "for i in trange(1000000):\n",
    "    feed = dict(zip((swipe_ph, swipe_len_ph, reference_answers),\n",
    "                            generate_batch(train_curves, batch_size=128),))\n",
    "    \n",
    "    loss_t = sess.run([loss, step], feed)[0]\n",
    "    history.append(loss_t)\n",
    "    \n",
    "    if i % 100 == 0:\n",
    "        clear_output(True)\n",
    "        plt.scatter(np.arange(len(history)), history, alpha=0.2)\n",
    "        plt.plot(ewma(history, span=10), label='loss_ewma@10')\n",
    "        plt.plot(ewma(history, span=100), label='loss_ewma@100')\n",
    "        plt.legend(loc='best')\n",
    "        plt.yscale('log')\n",
    "        plt.grid()\n",
    "        plt.show()\n",
    "        print(np.mean(history[-100:]))\n",
    "        plt.figure(figsize=[14,4])\n",
    "        _p, _len = sess.run([tf.nn.softmax(logits), swipe_len_ph], feed)\n",
    "        plt.imshow(_p[0, :_len[0]].T)\n",
    "        plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "translate(logits, tf.to_int32(swipe_len_ph), pad_ix=EOS_ix, decoder=tf.nn.ctc_greedy_decoder ).eval(feed)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "translate(logits, tf.to_int32(swipe_len_ph), pad_ix=EOS_ix, decoder=tf.nn.ctc_beam_search_decoder ).eval(feed)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reference_answers.eval(feed)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[tokens[i] for i in _265[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(tf.nn.softmax(logits).eval()[0][:20])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "translate(logits, tf.to_int32(swipe_len_ph), pad_ix=EOS_ix, decoder=tf.nn.ctc_beam_search_decoder ).eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "curve"
   ]
  }
 ],
 "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
}