Math_Part3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Math Part 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.date(2017, 2, 23)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import date\n",
    "date.today()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "author = \"kyubyong. https://github.com/Kyubyong/tensorflow-exercises\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.0.0'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.12.0'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sess = tf.InteractiveSession()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NOTE on notation\n",
    "* _x, _y, _z, ...: NumPy 0-d or 1-d arrays\n",
    "* _X, _Y, _Z, ...: NumPy 2-d or higer dimensional arrays\n",
    "* x, y, z, ...: 0-d or 1-d tensors\n",
    "* X, Y, Z, ...: 2-d or higher dimensional tensors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Compute the cumulative sum of X along the second axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Compute the cumulative product of X along the second axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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"
   ]
  },
  {
   "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": 9,
   "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"
   ]
  },
  {
   "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": 10,
   "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"
   ]
  },
  {
   "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": 11,
   "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"
   ]
  },
  {
   "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": 12,
   "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"
   ]
  },
  {
   "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": 13,
   "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"
   ]
  },
  {
   "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": 14,
   "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"
   ]
  },
  {
   "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": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_X = [[0 8 2 3 1]\n",
      " [4 6 7 9 5]]\n",
      "[1 3]\n",
      "[0 0]\n"
     ]
    }
   ],
   "source": [
    "_X = np.random.permutation(10).reshape((2, 5))\n",
    "print(\"_X =\", _X)\n",
    "X = tf.convert_to_tensor(_X)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q10. Find the unique elements of x that are not present in y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q11. Return the elements of X, if X < 4, otherwise X*10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q12. Get unique elements and their indices from x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q13. Compute the edit distance between hypothesis and truth."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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": 0
}