Math_Part2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Math Part 2"
   ]
  },
  {
   "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": 1,
   "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": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sess = tf.InteractiveSession()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix Math Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Create a diagonal tensor with the diagonal values of x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 0 0]\n",
      " [0 2 0 0]\n",
      " [0 0 3 0]\n",
      " [0 0 0 4]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([1, 2, 3, 4])\n",
    "x = tf.convert_to_tensor(_x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Extract the diagonal of x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array(\n",
    "[[1, 0, 0, 0],\n",
    " [0, 2, 0, 0],\n",
    " [0, 0, 3, 0],\n",
    " [0, 0, 0, 4]])\n",
    "x = tf.convert_to_tensor(_x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q3. Permutate the dimensions of x such that the new tensor has shape (3, 4, 2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4, 2)\n"
     ]
    }
   ],
   "source": [
    "_x = np.random.rand(2,3,4)\n",
    "x = tf.convert_to_tensor(_x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q4. Construct a 3 by 3 identity matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  0.  0.]\n",
      " [ 0.  1.  0.]\n",
      " [ 0.  0.  1.]]\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5. Predict the result of this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "_x = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "diagonal_tensor = tf.matrix_diag(x)\n",
    "diagonal_part = tf.matrix_diag_part(diagonal_tensor)\n",
    "\n",
    "#print(\"diagonal_tensor =\\n\", diagonal_tensor.eval())\n",
    "#print(\"diagonal_part =\\n\", diagonal_part.eval())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q6. Transpose the last two dimensions of x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 4, 3)\n"
     ]
    }
   ],
   "source": [
    "_x = np.random.rand(1, 2, 3, 4)\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q7. Multiply x by y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[14 14]\n",
      " [32 32]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "_y = np.array([[1, 1], [2, 2], [3, 3]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q8. Multiply slices of x and y in batches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[14 14]\n",
      "  [32 32]]\n",
      "\n",
      " [[14 14]\n",
      "  [32 32]]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]])\n",
    "_y = np.array([[[1, 1], [2, 2], [3, 3]], [[1, 1], [2, 2], [3, 3]]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q9. Compute the determinant of x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-2.0\n"
     ]
    }
   ],
   "source": [
    "_x = np.arange(1, 5, dtype=np.float32).reshape((2, 2))\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q10. Compute the inverse of x.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-2.   1. ]\n",
      " [ 1.5 -0.5]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.arange(1, 5, dtype=np.float64).reshape((2, 2))\n",
    "x = tf.convert_to_tensor(_x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q11. Get the lower-trianglular in the Cholesky decomposition of x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2.  0.  0.]\n",
      " [ 6.  1.  0.]\n",
      " [-8.  5.  3.]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array([[4, 12, -16], [12, 37, -43], [-16, -43, 98]], np.float32)\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q12. Compute the eigenvalues and eigenvectors of x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eigentvalues =\n",
      " [ 1.  2.  3.]\n",
      "eigenvectors =\n",
      " [[ 1.  0.  0.]\n",
      " [ 0.  1.  0.]\n",
      " [ 0.  0.  1.]]\n"
     ]
    }
   ],
   "source": [
    "_x = np.diag((1, 2, 3))\n",
    "x = tf.convert_to_tensor(_x, tf.float32)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q13. Compute the singular values of x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3.          2.23606801  2.          0.        ]\n"
     ]
    }
   ],
   "source": [
    "_x = np.array(\n",
    "[[1, 0, 0, 0, 2], \n",
    " [0, 0, 3, 0, 0], \n",
    " [0, 0, 0, 0, 0], \n",
    " [0, 2, 0, 0, 0]], dtype=np.float32)\n",
    "x = tf.convert_to_tensor(_x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q14. Predict the results of these."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "_x = np.array(\n",
    "    [[1, 2, 3, 4],\n",
    "     [5, 6, 7, 8]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "outs = [tf.reduce_sum(x),\n",
    "        tf.reduce_sum(x, axis=0),\n",
    "        tf.reduce_sum(x, axis=1, keep_dims=True),\n",
    "        \"\",\n",
    "        tf.reduce_prod(x),\n",
    "        tf.reduce_prod(x, axis=0),\n",
    "        tf.reduce_prod(x, axis=1, keep_dims=True),\n",
    "        \"\",\n",
    "        tf.reduce_min(x),\n",
    "        tf.reduce_min(x, axis=0),\n",
    "        tf.reduce_min(x, axis=1, keep_dims=True),\n",
    "        \"\",\n",
    "        tf.reduce_max(x),\n",
    "        tf.reduce_max(x, axis=0),\n",
    "        tf.reduce_max(x, axis=1, keep_dims=True),\n",
    "        \"\",\n",
    "        tf.reduce_mean(x),\n",
    "        tf.reduce_mean(x, axis=0),\n",
    "        tf.reduce_mean(x, axis=1, keep_dims=True)\n",
    "           ]\n",
    "           \n",
    "for out in outs:\n",
    "    if out == \"\":\n",
    "        #print()\n",
    "        pass\n",
    "    else:\n",
    "#         print(\"->\", out.eval())\n",
    "        pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q15. Predict the results of these."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "_x = np.array([[True, True],\n",
    "              [False, False]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "outs = [tf.reduce_all(x),\n",
    "        tf.reduce_all(x, axis=0),\n",
    "        tf.reduce_all(x, axis=1, keep_dims=True),\n",
    "        \"\",\n",
    "        tf.reduce_any(x),\n",
    "        tf.reduce_any(x, axis=0),\n",
    "        tf.reduce_any(x, axis=1, keep_dims=True),\n",
    "        ]\n",
    "\n",
    "for out in outs:\n",
    "    if out == \"\":\n",
    "#         print()\n",
    "        pass\n",
    "    else:\n",
    "#         print(\"->\", out.eval())\n",
    "        pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Q16. Predict the results of these."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "_x = np.array([[0, 1, 0],\n",
    "              [1, 1, 0]])\n",
    "x = tf.convert_to_tensor(_x)\n",
    "\n",
    "outs = [tf.count_nonzero(x),\n",
    "        tf.count_nonzero(x, axis=0),\n",
    "        tf.count_nonzero(x, axis=1, keep_dims=True),\n",
    "        ]\n",
    "\n",
    "for out in outs:\n",
    "#     print(\"->\", out.eval())\n",
    "    pass\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q17. Complete the einsum function that would yield the same result as the given function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "_x = np.arange(1, 7).reshape((2, 3))\n",
    "_y = np.arange(1, 7).reshape((3, 2))\n",
    "\n",
    "x = tf.convert_to_tensor(_x)\n",
    "y = tf.convert_to_tensor(_y)\n",
    "\n",
    "# Matrix multiplication\n",
    "out1 = tf.matmul(x, y)\n",
    "out1_ = tf.einsum('...', x, y)\n",
    "assert np.allclose(out1.eval(), out1_.eval())\n",
    "\n",
    "# Dot product\n",
    "flattened = tf.reshape(x, [-1])\n",
    "out2 = tf.reduce_sum(tf.mul(flattened, flattened))\n",
    "out2_ = tf.einsum('...', flattened, flattened)\n",
    "assert np.allclose(out2.eval(), out2_.eval())\n",
    "\n",
    "# Outer product\n",
    "expanded_a = tf.expand_dims(flattened, 1) # shape: (6, 1)\n",
    "expanded_b = tf.expand_dims(flattened, 0) # shape: (1, 6)\n",
    "out3 = tf.matmul(expanded_a, expanded_b)\n",
    "out3_ = tf.einsum('...', flattened, flattened)\n",
    "assert np.allclose(out3.eval(), out3_.eval())\n",
    "\n",
    "# Transpose\n",
    "out4 = tf.transpose(x) # shape: (3, 2)\n",
    "out4_ = tf.einsum('...', x)\n",
    "assert np.allclose(out4.eval(), out4_.eval())"
   ]
  },
  {
   "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
}