Math_Part3_Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Math Part 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "__author__ = \"kyubyong. kbpark.linguist@gmail.com. https://www.github.com/kyubyong\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: if a variable's name starts with _, it is a numpy array. I use it explicitly in order to compare tensorflow functions with numpy functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.12.0-rc1'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.11.2'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sys.version_info(major=3, minor=5, micro=1, releaselevel='final', serial=0)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.version_info # python version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sess = tf.InteractiveSession()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Compute the cumulative sum of x along axis 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  3  6]\n",
      " [ 4  9 15]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([[1,2,3], [4,5,6]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out = tf.cumsum(x, axis=1)\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.cumsum(_x, axis=1)\n",
    "assert np.array_equal(out.eval(), _out) # tf.cumsum == np.cumsum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Compute the cumulative product of x along axis 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1   2   6]\n",
      " [  4  20 120]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([[1,2,3], [4,5,6]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out = tf.cumprod(x, axis=1)\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.cumprod(_x, axis=1)\n",
    "assert np.array_equal(out.eval(), _out) # tf.cumprod == np.cumprod"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Segmentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q3. Compute the sum along the first two elements and \n",
    "the last two elements of x separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0]\n",
      " [0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array(\n",
    "    [[1,2,3,4], \n",
    "     [-1,-2,-3,-4], \n",
    "     [-10,-20,-30,-40],\n",
    "     [10,20,30,40]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out = tf.segment_sum(x, [0, 0, 1, 1])\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.vstack((_x[:2].sum(0), _x[2:].sum(0)))\n",
    "assert np.array_equiv(out.eval(), _out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q4. Compute the product along the first two elements and the last two elements of x separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.  1.  1.]\n",
      " [-1. -2. -3. -4.]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array(\n",
    "    [[1,2,3,4], \n",
    "     [1,1/2,1/3,1/4], \n",
    "     [1,2,3,4],\n",
    "     [-1,-1,-1,-1]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out = tf.segment_prod(x, [0, 0, 1, 1])\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.vstack((_x[:2].prod(0), _x[2:].prod(0)))\n",
    "assert np.array_equiv(out.eval(), _out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5. Compute the minimum along the first two elements and the last two elements of x separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  3  5  7]\n",
      " [-1 -2 -3 -4]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array(\n",
    "    [[1,4,5,7], \n",
    "     [2,3,6,8], \n",
    "     [1,2,3,4],\n",
    "     [-1,-2,-3,-4]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out = tf.segment_min(x, [0, 0, 1, 1])\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.vstack((_x[:2].min(0), _x[2:].min(0)))\n",
    "assert np.array_equiv(out.eval(), _out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q6. Compute the maximum along the first two elements and the last two elements of x separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 4 6 8]\n",
      " [1 2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array(\n",
    "    [[1,4,5,7], \n",
    "     [2,3,6,8], \n",
    "     [1,2,3,4],\n",
    "     [-1,-2,-3,-4]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out = tf.segment_max(x, [0, 0, 1, 1])\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.vstack((_x[:2].max(0), _x[2:].max(0)))\n",
    "assert np.array_equiv(out.eval(), _out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q7. Compute the mean along the first two elements and the last two elements of x separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3  4  5  6]\n",
      " [-3 -4 -5 -6]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array(\n",
    "    [[1,2,3,4], \n",
    "     [5,6,7,8], \n",
    "     [-1,-2,-3,-4],\n",
    "     [-5,-6,-7,-8]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out = tf.segment_mean(x, [0, 0, 1, 1])\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.vstack((_x[:2].mean(0), _x[2:].mean(0)))\n",
    "assert np.array_equiv(out.eval(), _out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q8. Compute the sum along the second and fourth and \n",
    "the first and third elements of x separately in the order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  9  18  27  36]\n",
      " [ -9 -18 -27 -36]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array(\n",
    "    [[1,2,3,4], \n",
    "     [-1,-2,-3,-4], \n",
    "     [-10,-20,-30,-40],\n",
    "     [10,20,30,40]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out = tf.unsorted_segment_sum(x, [1, 0, 1, 0], 2)\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.vstack((_x[1] + _x[3], _x[0] + _x[2]))\n",
    "assert np.array_equiv(out.eval(), _out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sequence Comparison and Indexing \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q9. Get the indices of maximum and minimum values of x along the second axis.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_x = [[8 9 6 0 7]\n",
      " [2 4 3 1 5]]\n",
      "[1 4]\n",
      "[3 3]\n"
     ]
    }
   ],
   "source": [
    "_x = np.random.permutation(10).reshape(2, 5)\n",
    "print(\"_x =\", _x)\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out1 = tf.argmax(x, axis=1)\n",
    "out2 = tf.argmin(x, axis=1)\n",
    "print(out1.eval())\n",
    "print(out2.eval())\n",
    "\n",
    "_out1 = np.argmax(_x, axis=1)\n",
    "_out2 = np.argmin(_x, axis=1)\n",
    "assert np.allclose(out1.eval(), _out1)\n",
    "assert np.allclose(out2.eval(), _out2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q10. Find the unique elements of x that are not present in y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 5]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([0, 1, 2, 5, 0])\n",
    "_y = np.array([0, 1, 4])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "\n",
    "out = tf.setdiff1d(x, y)[0]\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.setdiff1d(_x, _y)\n",
    "assert np.array_equal(out.eval(), _out)\n",
    "# Note that tf.setdiff1d returns a tuple of (out, idx),\n",
    "# whereas np.setdiff1d returns out only."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q11. Return the elements of x, if x < 4, otherwise x*10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [40 50 60]\n",
      " [70 80 90]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.arange(1, 10).reshape(3, 3)\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out = tf.where(x < 4, x, x*10)\n",
    "print(out.eval())\n",
    "\n",
    "_out = np.where(_x < 4, _x, _x*10)\n",
    "assert np.array_equal(out.eval(), _out) # tf.where == np.where\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q12. Get unique elements and their indices from x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 6 4 3]\n",
      "[0 1 2 3 1 4 1]\n",
      "sorted unique elements = [1 2 3 4 6]\n",
      "indices = [0 1 4 3 1 2 1]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1, 2, 6, 4, 2, 3, 2])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "out, indices = tf.unique(x)\n",
    "print(out.eval())\n",
    "print(indices.eval())\n",
    "\n",
    "_out, _indices = np.unique(_x, return_inverse=True)\n",
    "print(\"sorted unique elements =\", _out)\n",
    "print(\"indices =\", _indices)\n",
    "\n",
    "# Note that tf.unique keeps the original order, whereas\n",
    "# np.unique sorts the unique members.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q13. Compute the edit distance between hypothesis and truth."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2.]\n",
      "[ 0.66666669]\n"
     ]
    }
   ],
   "source": [
    "# Check the documentation on tf.SparseTensor if you are not\n",
    "# comfortable with sparse tensor.\n",
    "hypothesis = tf.SparseTensor(\n",
    "    [[0, 0],[0, 1],[0, 2],[0, 4]],\n",
    "    [\"a\", \"b\", \"c\", \"a\"],\n",
    "    (1, 5)) \n",
    "# Note that this is equivalent to the dense tensor.\n",
    "# [[\"a\", \"b\", \"c\", 0, \"a\"]]\n",
    "\n",
    "truth = tf.SparseTensor(\n",
    "    [[0, 0],[0, 2],[0, 4]],\n",
    "    [\"a\", \"c\", \"b\"],\n",
    "    (1, 6))\n",
    "# This is equivalent to the dense tensor.\n",
    "# [[\"a\", 0, \"c\", 0, \"b\", 0]]\n",
    "\n",
    "out1 = tf.edit_distance(hypothesis, truth, normalize=False)\n",
    "out2 = tf.edit_distance(hypothesis, truth, normalize=True)\n",
    "print(out1.eval()) # 2 <- one deletion (\"b\") and one substitution (\"a\" to \"b\")\n",
    "print(out2.eval()) # 0.6666 <- 2 / 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}