Tensor_Transformations_Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensor Transformations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "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, 22)"
      ]
     },
     "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": 6,
   "metadata": {
    "collapsed": true
   },
   "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": [
    "## Casting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Let X be a tensor of [[\"1.1\", \"2.2\"], [\"3.3\", \"4.4\"]]. Convert the datatype of X to float32."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.10000002  2.20000005]\n",
      " [ 3.29999995  4.4000001 ]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[\"1.1\", \"2.2\"], [\"3.3\", \"4.4\"]])\n",
    "X = tf.constant(_X)\n",
    "out = tf.string_to_number(X)\n",
    "print(out.eval())\n",
    "assert np.allclose(out.eval(), _X.astype(np.float32))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Let X be a tensor [[1, 2], [3, 4]] of int32. Convert the data type of X to float64."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  2.]\n",
      " [ 3.  4.]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[1, 2], [3, 4]], dtype=np.int32)\n",
    "X = tf.constant(_X)\n",
    "out1 = tf.to_double(X)\n",
    "out2 = tf.cast(X, tf.float64)\n",
    "assert np.allclose(out1.eval(), out2.eval())\n",
    "print(out1.eval())\n",
    "assert np.allclose(out1.eval(), _X.astype(np.float64))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q3. Let X be a tensor [[1, 2], [3, 4]] of int32. Convert the data type of X to float32."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  2.]\n",
      " [ 3.  4.]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[1, 2], [3, 4]], dtype=np.int32)\n",
    "X = tf.constant(_X)\n",
    "out1 = tf.to_float(X)\n",
    "out2 = tf.cast(X, tf.float32)\n",
    "assert np.allclose(out1.eval(), out2.eval())\n",
    "print(out1.eval())\n",
    "assert np.allclose(out1.eval(), _X.astype(np.float32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q4. Let X be a tensor [[1, 2], [3, 4]] of float32. Convert the data type of X to int32."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[1, 2], [3, 4]], dtype=np.float32)\n",
    "X = tf.constant(_X)\n",
    "out1 = tf.to_int32(X)\n",
    "out2 = tf.cast(X, tf.int32)\n",
    "assert np.allclose(out1.eval(), out2.eval())\n",
    "print(out1.eval())\n",
    "assert np.allclose(out1.eval(), _X.astype(np.int32))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5. Let X be a tensor [[1, 2], [3, 4]] of float32. Convert the data type of X to int64."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[1, 2], [3, 4]], dtype=np.float32)\n",
    "X = tf.constant(_X)\n",
    "out1 = tf.to_int64(X)\n",
    "out2 = tf.cast(X, tf.int64)\n",
    "assert np.allclose(out1.eval(), out2.eval())\n",
    "print(out1.eval())\n",
    "assert np.allclose(out1.eval(), _X.astype(np.int64))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shapes and Shaping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q6. Let X be a tensor of [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]]. Create a tensor representing the shape of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 2 2]\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]])\n",
    "X = tf.constant(_X)\n",
    "out = tf.shape(X) \n",
    "print(out.eval())\n",
    "assert np.allclose(out.eval(), _X.shape) # tf.shape() == np.ndarray.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q7. Let X be a tensor of [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]]) and y be a tensor [10, 20]. Create a list of tensors representing the shape of X and y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 2 2] [2]\n"
     ]
    }
   ],
   "source": [
    "X = tf.constant([[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]])\n",
    "y = tf.constant([10, 20])\n",
    "out_X, out_y = tf.shape_n([X, y]) \n",
    "print(out_X.eval(), out_y.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q8. Let X be a tensor of [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]]. Create a tensor representing the size (=total number of elements) of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]])\n",
    "X = tf.constant(_X)\n",
    "out = tf.size(X)\n",
    "print(out.eval())\n",
    "assert out.eval() == _X.size # tf.size() == np.ndarry.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q9. Let X be a tensor of [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]]. Create a tensor representing the rank (=number of dimensions) of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]])\n",
    "X = tf.constant(_X)\n",
    "out = tf.rank(X)\n",
    "print(out.eval())\n",
    "assert out.eval() == _X.ndim # tf.rank() == np.ndarray.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q10. Let X be tf.ones([10, 10, 3]). Reshape X so that the size of the second dimension equals 150."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.]\n",
      " [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.  1.\n",
      "   1.  1.  1.  1.  1.  1.]]\n"
     ]
    }
   ],
   "source": [
    "X = tf.ones([10, 10, 3])\n",
    "out = tf.reshape(X, [-1, 150])\n",
    "print(out.eval())\n",
    "assert np.allclose(out.eval(), np.reshape(np.ones([10, 10, 3]), [-1, 150]))\n",
    "# tf.reshape(tensor, hape) == np.reshape(array, shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q11. Let X be tf.ones([10, 10, 1, 1]). Remove all the dimensions of size 1 in X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 10)\n"
     ]
    }
   ],
   "source": [
    "X = tf.ones([10, 10, 1, 1])\n",
    "out = tf.squeeze(X)\n",
    "print(out.eval().shape)\n",
    "assert np.allclose(out.eval(), np.squeeze(np.ones([10, 10, 1, 1])))\n",
    "# tf.squeeze(tensor) == np.squeeze(array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q12. Let X be tf.ones([10, 10, 1, 1]). Remove only the third dimension in X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 10, 1)\n"
     ]
    }
   ],
   "source": [
    "X = tf.ones([10, 10, 1, 1])\n",
    "out = tf.squeeze(X, [2])\n",
    "print(out.eval().shape)\n",
    "assert np.allclose(out.eval(), np.squeeze(np.ones([10, 10, 1, 1]), 2))\n",
    "# tf.squeeze(tensor, axis) == np.squeeze(array, axis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q13. Let X be tf.ones([10, 10]). Add a dimension of 1 at the end of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 10, 1)\n"
     ]
    }
   ],
   "source": [
    "X = tf.ones([10, 10])\n",
    "out = tf.expand_dims(X, -1)\n",
    "print(out.eval().shape)\n",
    "assert np.allclose(out.eval(), np.expand_dims(np.ones([10, 10]), -1))\n",
    "# tf.expand_dims(tensor, axis) == np.expand_dims(array, axis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing and Joining"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q14. Let X be a tensor<br/>\n",
    "[[[1, 1, 1], [2, 2, 2]],<br/>\n",
    "[[3, 3, 3], [4, 4, 4]],<br/>\n",
    "[[5, 5, 5], [6, 6, 6]]].<br/>\n",
    "Extract the [[[3, 3, 3], [5, 5, 5]] from X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[3 3 3]]\n",
      "\n",
      " [[5 5 5]]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[[1, 1, 1], \n",
    "                 [2, 2, 2]],\n",
    "                [[3, 3, 3], \n",
    "                 [4, 4, 4]],\n",
    "                [[5, 5, 5], \n",
    "                 [6, 6, 6]]])\n",
    "X = tf.constant(_X)\n",
    "out = tf.slice(X, [1, 0, 0], [2, 1, 3])\n",
    "print(out.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q15. Let X be a tensor of<br/>\n",
    "[[ 1  2]<br />\n",
    " [ 3  4]<br />\n",
    " [ 5  6]<br />\n",
    " [ 7  8]<br />\n",
    " [ 9 10]].<br />\n",
    " Extract the [[1, 2], [5, 6], [9, 10]]] from X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2]\n",
      " [ 5  6]\n",
      " [ 9 10]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.arange(1, 11).reshape([5, 2])\n",
    "X = tf.convert_to_tensor(_X)\n",
    "out = tf.strided_slice(X, begin=[0], end=[5], strides=[2])\n",
    "print(out.eval())\n",
    "assert np.allclose(out.eval(), _X[[0, 2, 4]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q16. Let X be a tensor of<br/>\n",
    "[[ 1  2  3  4  5]<br />\n",
    " [ 6  7  8  9  10]].<br />\n",
    "Split X into 5 same-sized tensors along the second dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[1],\n",
      "       [6]]), array([[2],\n",
      "       [7]]), array([[3],\n",
      "       [8]]), array([[4],\n",
      "       [9]]), array([[ 5],\n",
      "       [10]])]\n"
     ]
    }
   ],
   "source": [
    "_X = np.arange(1, 11).reshape([2, 5])\n",
    "X = tf.convert_to_tensor(_X)\n",
    "out = tf.split(X, 5, axis=1) # Note that the order of arguments has changed in TensorFlow 1.0\n",
    "print([each.eval() for each in out])\n",
    "comp = np.array_split(_X, 5, 1) \n",
    "# tf.split(tensor, num_or_size_splits, axis) == np.array_split(array, indices_or_sections, axis=0)\n",
    "assert np.allclose([each.eval() for each in out], comp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q17. Lex X be a tensor<br/>\n",
    "[[ 1 2 3]<br/>\n",
    " [ 4 5 6].<br/>\n",
    "Create a tensor looking like <br/>\n",
    "[[ 1 2 3 1 2 3 1 2 3 ]<br/>\n",
    " [ 4 5 6 4 5 6 4 5 6 ]]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 1 2 3 1 2 3]\n",
      " [4 5 6 4 5 6 4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.arange(1, 7).reshape((2, 3))\n",
    "X = tf.convert_to_tensor(_X)\n",
    "out = tf.tile(X, [1, 3])\n",
    "print(out.eval())\n",
    "assert np.allclose(out.eval(), np.tile(_X, [1, 3]))\n",
    "# tf.tile(tensor, multiples) == np.tile(array, reps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q18. Lex X be a tensor <br/>\n",
    "[[ 1 2 3]<br/>\n",
    " [ 4 5 6].<br/>\n",
    "Pad 2 * 0's before the first dimension, 3 * 0's after the second dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0 0 0]\n",
      " [0 0 0 0 0 0]\n",
      " [1 2 3 0 0 0]\n",
      " [4 5 6 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.arange(1, 7).reshape((2, 3))\n",
    "X = tf.convert_to_tensor(_X)\n",
    "out = tf.pad(X, [[2, 0], [0, 3]])\n",
    "print(out.eval())\n",
    "assert np.allclose(out.eval(), np.pad(_X, [[2, 0], [0, 3]], 'constant', constant_values=[0, 0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q19. Lex X be a tensor <br/>\n",
    "[[ 1 2 3]<br/>\n",
    " [ 4 5 6].<br/>\n",
    "and Y be a tensor<br/>\n",
    "[[ 7 8 9]<br/>\n",
    " [10 11 12]].<br/>\n",
    "Concatenate X and Y so that the new tensor looks like [[1, 2, 3, 7, 8, 9], [4, 5, 6, 10, 11, 12]]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  7  8  9]\n",
      " [ 4  5  6 10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "_Y = np.array([[7, 8, 9], [10, 11, 12]])\n",
    "X = tf.constant(_X)\n",
    "Y = tf.constant(_Y)\n",
    "out = tf.concat([X, Y], 1) # Note that the order of arguments has changed in TF 1.0!\n",
    "print(out.eval())\n",
    "assert np.allclose(out.eval(), np.concatenate((_X, _Y), 1))\n",
    "# tf.concat == np.concatenate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q20. Let x, y, and z be tensors [1, 4], [2, 5], and [3, 6], respectively. <br/>Create a single tensor from these such that it looks [[1, 2, 3], [4, 5, 6]]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([1, 4])\n",
    "y = tf.constant([2, 5])\n",
    "z = tf.constant([3, 6])\n",
    "out = tf.stack([x, y, z], 1)\n",
    "print(out.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q21. Let X be a tensor [[1, 2, 3], [4, 5, 6]]. Convert X into Y such that Y looks like [[1, 4], [2, 5], [3, 6]]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([1, 4]), array([2, 5]), array([3, 6])]\n"
     ]
    }
   ],
   "source": [
    "X = tf.constant([[1, 2, 3], [4, 5, 6]])\n",
    "Y = tf.unstack(X, axis=1)\n",
    "print([each.eval() for each in Y])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q22. Given X below, reverse the sequence along the second axis except the zero-paddings. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0, 1, 0],\n",
       "        [0, 0, 1],\n",
       "        [0, 0, 0]],\n",
       "\n",
       "       [[1, 0, 0],\n",
       "        [0, 1, 0],\n",
       "        [0, 0, 1]]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = tf.constant(\n",
    "[[[0, 0, 1],\n",
    "  [0, 1, 0],\n",
    "  [0, 0, 0]],\n",
    " \n",
    " [[0, 0, 1],\n",
    "  [0, 1, 0],\n",
    "  [1, 0, 0]]])\n",
    "\n",
    "out = tf.reverse_sequence(X, [2, 3], seq_axis=1, batch_axis=0)\n",
    "out.eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q23. Given X below, reverse the last dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[[ 4  3  2  1]\n",
      "   [ 8  7  6  5]\n",
      "   [12 11 10  9]]\n",
      "\n",
      "  [[16 15 14 13]\n",
      "   [20 19 18 17]\n",
      "   [24 23 22 21]]]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.arange(1, 1*2*3*4 + 1).reshape((1, 2, 3, 4))\n",
    "X = tf.convert_to_tensor(_X)\n",
    "out = tf.reverse(X, [-1]) #Note that tf.reverse has changed its behavior in TF 1.0.\n",
    "print(out.eval())\n",
    "assert np.allclose(out.eval(), _X[:, :, :, ::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q24. Given X below, permute its dimensions such that the new tensor has shape (3, 1, 2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 1, 2)\n"
     ]
    }
   ],
   "source": [
    "_X = np.ones((1, 2, 3))\n",
    "X = tf.convert_to_tensor(_X)\n",
    "out = tf.transpose(X, [2, 0, 1])\n",
    "print(out.eval().shape)\n",
    "assert np.allclose(out.eval(), np.transpose(_X))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q25. Given X, below, get the first, and third rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.arange(1, 10).reshape((3, 3))\n",
    "X = tf.convert_to_tensor(_X)\n",
    "out1 = tf.gather(X, [0, 2])\n",
    "out2 = tf.gather_nd(X, [[0], [2]])\n",
    "assert np.allclose(out1.eval(), out2.eval())\n",
    "print(out1.eval())\n",
    "assert np.allclose(out1.eval(), _X[[0, 2]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q26. Given X below, get the elements 5 and 7."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 7]\n"
     ]
    }
   ],
   "source": [
    "_X = np.arange(1, 10).reshape((3, 3))\n",
    "X = tf.convert_to_tensor(_X)\n",
    "out = tf.gather_nd(X, [[1, 1], [2, 0]])\n",
    "print(out.eval())\n",
    "assert np.allclose(out.eval(), _X[[1, 2], [1, 0]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q27. Let x be a tensor [2, 2, 1, 5, 4, 5, 1, 2, 3]. Get the tensors of unique elements and their counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 1 5 4 3] [3 2 2 1 1]\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([2, 2, 1, 5, 4, 5, 1, 2, 3])\n",
    "out1, _, out2 = tf.unique_with_counts(x)\n",
    "print(out1.eval(), out2.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q28. Let x be a tensor [1, 2, 3, 4, 5]. Divide the elements of x into a list of tensors that looks like [[3, 5], [1], [2, 4]]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([3, 5]), array([1]), array([2, 4])]\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([1, 2, 3, 4, 5])\n",
    "out = tf.dynamic_partition(x, [1, 2, 0, 2, 0], 3)\n",
    "print([each.eval() for each in out])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q29. Let X be a tensor [[7, 8], [5, 6]] and Y be a tensor [[1, 2], [3, 4]]. Create a single tensor looking like [[1, 2], [3, 4], [5, 6], [7, 8]]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]\n",
      " [7 8]]\n"
     ]
    }
   ],
   "source": [
    "X = tf.constant([[7, 8], [5, 6]])\n",
    "Y = tf.constant([[1, 2], [3, 4]])\n",
    "out = tf.dynamic_stitch([[3, 2], [0, 1]], [X, Y])\n",
    "print(out.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q30. Let x be a tensor [0, 1, 2, 3] and y be a tensor [True, False, False, True].<br/>\n",
    "Apply mask y to x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 3]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([0, 1, 2, 3])\n",
    "_y = np.array([True, False, False, True])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "out = tf.boolean_mask(x, y)\n",
    "print(out.eval())\n",
    "assert np.allclose(out.eval(), _x[_y])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q31. Let X be a tensor [[0, 5, 3], [4, 2, 1]]. Convert X into one-hot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  0.  0.  0.  0.  0.]\n",
      " [ 0.  1.  0.  0.  0.  0.]\n",
      " [ 0.  0.  1.  0.  0.  0.]\n",
      " [ 0.  0.  0.  1.  0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "X = tf.constant([[0, 5, 3], [4, 2, 1]])\n",
    "out = tf.one_hot(x, 6)\n",
    "print(out.eval())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "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
}