frameworks/tensorflow/Tips_Tensorflow.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-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"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensorflow version: 1.11.0\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "\n",
    "print(\"Tensorflow version: {}\".format(tf.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control Dependencies and Identity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Original (Wrong)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /anaconda3/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "1.0\n",
      "1.0\n",
      "1.0\n",
      "1.0\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "with tf.variable_scope(\"cdi\"):\n",
    "    x = tf.Variable(1.0)\n",
    "    y = tf.Variable(0.0)\n",
    "    \n",
    "    x_plus_1 = tf.assign_add(x, 1)\n",
    "    \n",
    "    with tf.control_dependencies([x_plus_1]):\n",
    "        y = x\n",
    "        \n",
    "    with tf.Session() as sess:\n",
    "        sess.run(tf.global_variables_initializer())\n",
    "        for i in range(5):\n",
    "            print(sess.run(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compare (Correct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`tf.control_dependencies` only change the defined operation (`tf.identity`), the `y = x` is the first assignment, not the operation. `tf.identity` is the operation which returns the same tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "3.0\n",
      "4.0\n",
      "5.0\n",
      "6.0\n"
     ]
    }
   ],
   "source": [
    "with tf.variable_scope(\"cdi\"):\n",
    "    x = tf.Variable(1.0)\n",
    "    y = tf.Variable(0.0)\n",
    "    \n",
    "    x_plus_1 = tf.assign_add(x, 1)\n",
    "    \n",
    "    with tf.control_dependencies([x_plus_1]):\n",
    "        y = tf.identity(x)   # the only change\n",
    "        \n",
    "    with tf.Session() as sess:\n",
    "        sess.run(tf.global_variables_initializer())\n",
    "        for i in range(5):\n",
    "            print(sess.run(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loop in Tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "i = tf.constant(0)\n",
    "c = lambda i: tf.less(i, 10)\n",
    "b = lambda i: tf.add(i, 1)\n",
    "r = tf.while_loop(c, b, [i])\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run(r))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 285)\n"
     ]
    }
   ],
   "source": [
    "with tf.variable_scope(\"while_loop\"):\n",
    "    index = tf.constant(0)\n",
    "    sum_all = tf.constant(0)\n",
    "    \n",
    "    # loop_vars must be passed into both functions cond and body\n",
    "    # *_ means all the other parameters\n",
    "    cond = lambda index, *_: tf.less(index, 10)  \n",
    "    def cond_worse(index, sum_all):\n",
    "        return tf.less(index, 10)\n",
    "    \n",
    "    # loop_vars must be passed into both functions cond and body\n",
    "    def body(index, sum_all):\n",
    "        tmp = tf.add(sum_all, tf.pow(index, 2))\n",
    "        index += 1  # you have to increament by yourself\n",
    "        return (index, tmp)\n",
    "    \n",
    "    # return the same body with loop_vars\n",
    "    # r = (index, sum_all)\n",
    "    r = tf.while_loop(cond=cond, body=body, loop_vars=[index, sum_all])\n",
    "    \n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    print(sess.run(r))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "cond = lambda index, *_: index < 10\n",
    "print(cond(12, 'a', 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]\n",
      " [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]\n",
      " [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]\n",
      " [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]\n",
      " [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]\n",
      " [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]\n",
      " [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]\n",
      " [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]\n",
      " [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]\n",
      " [2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]]\n"
     ]
    }
   ],
   "source": [
    "# 20 sequence in the length of 10\n",
    "matrix = tf.placeholder(tf.int32, shape=(10, 20), name=\"input_matrix\")\n",
    "matrix_rows = tf.shape(matrix)[0]\n",
    "ta = tf.TensorArray(dtype=tf.int32, size=matrix_rows)\n",
    "\n",
    "init_state = (0, ta)\n",
    "condition = lambda i, _: i < matrix_rows\n",
    "body = lambda i, ta: (i + 1, ta.write(i, matrix[i] * 2))\n",
    "n, ta_final = tf.while_loop(condition, body, init_state)\n",
    "# get the final result\n",
    "ta_final_result = ta_final.stack()\n",
    "\n",
    "# run the graph\n",
    "with tf.Session() as sess:\n",
    "    # print the output of ta_final_result\n",
    "    print(sess.run(ta_final_result, feed_dict={matrix: np.ones(shape=(10,20), dtype=np.int32)}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# tf.clip_by_value()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Narrow the value in the array to [min, max]. The value is min if it is smaller than the min value. The value is max if it is bigger than the max value. The value is the same if it is bigger than the min value, but is smaller then the max value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2.426633    0.3751102   2.6840754   0.66835743  0.0943675   2.0987873\n",
      " -3.2778037  -2.5711484   0.5976639   0.90391505]\n",
      "[2.         0.3751102  2.         0.66835743 0.0943675  2.\n",
      " 0.         0.         0.5976639  0.90391505]\n"
     ]
    }
   ],
   "source": [
    "with tf.variable_scope(\"clip\") as scope:\n",
    "    scope.reuse_variables()\n",
    "    int_val = tf.get_variable(\"intval\", [10], initializer=tf.random_normal_initializer(stddev=2.0))\n",
    "    int_val_clip = tf.clip_by_value(int_val, 0, 2)\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    print(sess.run(int_val))\n",
    "    print(sess.run(int_val_clip))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6403636488770224"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(0.3751102 - (-3.2778037)) / (2.426633 - (-3.2778037)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Coordinator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "De: 13.0\n",
      "De: 28.0\n",
      "De: 41.0\n",
      "De: 54.0\n",
      "De: 68.0\n",
      "De: 87.0\n",
      "De: 107.0\n",
      "De: 125.0\n",
      "De: 139.0\n",
      "De: 159.0\n"
     ]
    }
   ],
   "source": [
    "def Coord():\n",
    "    q = tf.FIFOQueue(10, \"float\")\n",
    "    counter = tf.Variable(0.0)\n",
    "    increment_op = tf.assign_add(counter, tf.constant(1.0))\n",
    "\n",
    "    enqueue_op = q.enqueue([counter])\n",
    "    qr = tf.train.QueueRunner(q, enqueue_ops=[increment_op, enqueue_op] * 1)\n",
    "\n",
    "    with tf.Session() as sess:\n",
    "        sess.run(tf.global_variables_initializer())\n",
    "\n",
    "        # coordinator\n",
    "        crd = tf.train.Coordinator()\n",
    "        \n",
    "        # start to add value (a thread) and add it into queue (another thread)\n",
    "        enqueue_threads = qr.create_threads(sess, coord=crd, start=True)\n",
    "\n",
    "        # start to fetch value from queue\n",
    "        for i in range(10):\n",
    "            print(\"De: {}\".format(sess.run(q.dequeue())))\n",
    "\n",
    "        # stop \n",
    "        crd.request_stop()\n",
    "        crd.join(enqueue_threads)\n",
    "        \n",
    "Coord()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# concat vs. stack "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with tf.variable_scope(\"concat\") as scope:\n",
    "    #ar1 = tf.random_normal([1,1,224,224])\n",
    "    scope.reuse_variables()\n",
    "    ar3 = tf.get_variable(\"ar3\", [1,1,224,224], initializer=tf.random_normal_initializer(stddev=(0.1)))\n",
    "    ar4 = tf.get_variable(\"ar4\", [1,1,224,224], initializer=tf.random_normal_initializer(stddev=(0.1)))\n",
    "    ar5 = tf.concat([ar3,ar4], axis=1)\n",
    "    sh = tf.shape(ar5)\n",
    "    \n",
    "    ar3_1 = tf.squeeze(ar3, [0,1])\n",
    "    ar4_1 = tf.squeeze(ar4, [0,1])\n",
    "    stk = tf.expand_dims(tf.stack([ar3_1,ar4_1]), 0)\n",
    "    stk_shape = tf.shape(stk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  1   1 224 224]\n",
      "[  1   1 224 224]\n",
      "[  1   2 224 224]\n",
      "[  1   2 224 224]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    print(sess.run(tf.shape(ar1)))\n",
    "    print(sess.run(tf.shape(ar2)))\n",
    "    print(sess.run(sh))\n",
    "    print(sess.run(stk_shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# tf.tile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0]\n",
      " [2 1]] \n",
      " [[1 0 1 0]\n",
      " [2 1 2 1]]\n"
     ]
    }
   ],
   "source": [
    "with tf.variable_scope(\"tf_tile\"):\n",
    "    data = tf.random_uniform([2,2], minval=0, maxval=5, dtype=tf.int32)\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    oriData, tileData = sess.run([data, tf.tile(data, [1,2])])\n",
    "    print(oriData, \"\\n\", tileData)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reduced Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## reduced_sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[  1   1   1]\n",
      "  [  2   2   2]\n",
      "  [ 10  10  10]]\n",
      "\n",
      " [[ 20  20  20]\n",
      "  [100 100 100]\n",
      "  [200 200 200]]]\n",
      "(2, 3, 3)\n",
      "\n",
      "999\n",
      "\n",
      "[[ 21  21  21]\n",
      " [102 102 102]\n",
      " [210 210 210]]\n",
      "(3, 3)\n",
      "\n",
      "[[ 13  13  13]\n",
      " [320 320 320]]\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "with tf.variable_scope(\"reduced_sum\") as scope:\n",
    "    sum_array = tf.constant([[[1,1,1], [2,2,2], [10,10,10]], [[20,20,20], [100,100,100], [200,200,200]]])\n",
    "    axis_0 = tf.reduce_sum(sum_array, 0)\n",
    "    axis_1 = tf.reduce_sum(sum_array, 1)\n",
    "    \n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    print(sess.run(sum_array))\n",
    "    print(sess.run(sum_array).shape)\n",
    "    print()\n",
    "    print(sess.run(tf.reduce_sum(sum_array)))\n",
    "    print()\n",
    "    print(sess.run(axis_0))\n",
    "    print(sess.run(axis_0).shape)\n",
    "    print()\n",
    "    print(sess.run(axis_1))\n",
    "    print(sess.run(axis_1).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## reduced_mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[  1   1   1]\n",
      "  [  2   2   2]\n",
      "  [ 10  10  10]]\n",
      "\n",
      " [[ 20  20  20]\n",
      "  [100 100 100]\n",
      "  [200 200 200]]]\n",
      "(2, 3, 3)\n",
      "\n",
      "55\n",
      "\n",
      "[[ 10  10  10]\n",
      " [ 51  51  51]\n",
      " [105 105 105]]\n",
      "(3, 3)\n",
      "\n",
      "[[  4   4   4]\n",
      " [106 106 106]]\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "with tf.variable_scope(\"reduced_mean\") as scope:\n",
    "    mean_array = tf.constant([[[1,1,1], [2,2,2], [10,10,10]], [[20,20,20], [100,100,100], [200,200,200]]])\n",
    "    axis_0 = tf.reduce_mean(mean_array, 0)\n",
    "    axis_1 = tf.reduce_mean(mean_array, 1)\n",
    "    \n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    print(sess.run(mean_array))\n",
    "    print(sess.run(mean_array).shape)\n",
    "    print()\n",
    "    print(sess.run(tf.reduce_mean(sum_array)))\n",
    "    print()\n",
    "    print(sess.run(axis_0))\n",
    "    print(sess.run(axis_0).shape)\n",
    "    print()\n",
    "    print(sess.run(axis_1))\n",
    "    print(sess.run(axis_1).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# tf.Tensorarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data: [[1 7 0 5]]\n",
      "sorted: [[ 0 -1 -5 -7]], reversed: [[0 1 5 7]]\n",
      "free: [[2 0 3 1]]\n",
      "data2: [[108 170 171 110]]\n",
      "full_at: [170 110 108 171]\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "with tf.variable_scope(\"allloc\"):\n",
    "    data = tf.random_uniform([1,4], minval=0, maxval=10, dtype=tf.int32)\n",
    "    sorted_ut, free_list = tf.nn.top_k(-1 * data, 4)\n",
    "    \n",
    "    data2 = tf.random_uniform([1,4], minval=100, maxval=200, dtype=tf.int32)\n",
    "    empty_at = tf.TensorArray(tf.int32, 4)\n",
    "    full_at = empty_at.scatter(\n",
    "            tf.reshape(free_list, (-1,)), \n",
    "            tf.reshape(data2, (-1,)))\n",
    "    a_t = full_at.stack()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    d, s, f, d2, a_t = sess.run([data, sorted_ut, free_list, data2, a_t])\n",
    "    print(\"data: {}\".format(d))\n",
    "    print(\"sorted: {}, reversed: {}\".format(s,s*(-1)))\n",
    "    print(\"free: {}\".format(f))\n",
    "    print(\"data2: {}\".format(d2))\n",
    "    print(\"full_at: {}\".format(a_t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.50065833 -0.8159259   0.86088264  2.7285786  -1.900892   -0.8135131\n",
      " -0.5319745   0.17028719  1.9458723  -0.31174654] \n",
      " [-0.50065833  0.1840741   4.8608828  11.728579   14.099108   24.186487\n",
      " 35.468025   49.170288   65.94587    80.688255  ]\n"
     ]
    }
   ],
   "source": [
    "with tf.variable_scope(\"tensorarray\"):\n",
    "    values = tf.random_normal([10])\n",
    "    \n",
    "    index = tf.constant(0)\n",
    "    tmp = tf.constant(0.0)\n",
    "    \n",
    "    values_array = tf.TensorArray(tf.float32, 10)\n",
    "    values_array = values_array.unstack(values)\n",
    "    final_array = tf.TensorArray(tf.float32, 10)\n",
    "    \n",
    "    cond = lambda index, *_: tf.less(index, 10)\n",
    "    def body(index, values_array, final_array, tmp):\n",
    "        current_value = values_array.read(index)\n",
    "        tmp = current_value + tf.cast(tf.pow(index, 2), dtype=tf.float32)\n",
    "        final_array = final_array.write(index, tmp)\n",
    "        index += 1\n",
    "        return (index, values_array, final_array, tmp)\n",
    "    \n",
    "    _, _, fin, _ = tf.while_loop(cond=cond, body=body, loop_vars=[index, values_array, final_array, tmp])\n",
    "    \n",
    "    fin = fin.stack()\n",
    "    \n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    val, finarry = sess.run([values, fin])\n",
    "    print(val, \"\\n\", finarry)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.44759494  0.68972546  1.712836   -1.773806    1.0969163  -0.26527986\n",
      " -0.62892115  0.21904905  0.5325642  -1.0592977 ] \n",
      " [-0.44759494  0.68972546  1.712836   -1.773806    1.0969163  -0.26527986\n",
      " -0.62892115  0.21904905  0.5325642  -1.0592977 ]\n"
     ]
    }
   ],
   "source": [
    "with tf.variable_scope(\"tensorarray2\"):\n",
    "    values = tf.random_normal([10])\n",
    "    values_array = tf.TensorArray(tf.float32, 10)\n",
    "    values_array = values_array.unstack(values)\n",
    "    values_array_transform = values_array.stack()\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    values, values_array_transform = sess.run([values, values_array_transform])\n",
    "    print(values, \"\\n\", values_array_transform)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# tf.get_collection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0]\n",
      "[[ 4.365282  9.835556 11.242051]\n",
      " [13.176279  5.793268 10.558922]]\n",
      "[array([[ 4.365282,  9.835556, 11.242051],\n",
      "       [13.176279,  5.793268, 10.558922]], dtype=float32)]\n"
     ]
    }
   ],
   "source": [
    "with tf.Graph().as_default():\n",
    "  with tf.variable_scope(\"pn\"):\n",
    "    a = tf.constant(0, dtype='float32', name=\"va\")\n",
    "    b = tf.constant(1, dtype='float32', name=\"vb\")\n",
    "    c = tf.get_variable(\"vc\", shape=[2, 3], initializer=tf.random_normal_initializer(10.0, 2.0))\n",
    "    \n",
    "    with tf.Session() as sess:\n",
    "      sess.run(tf.global_variables_initializer())\n",
    "      print(sess.run([a+b]))\n",
    "  \n",
    "  ns = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=\"pn\")\n",
    "  with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    c_, ns_ = sess.run([c, ns])\n",
    "    print(c_)\n",
    "    print(ns_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}