Math_Part2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Math Part 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": 2,
   "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": [
    "## Matrix Math Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Create a diagonal tensor with the diagonal values of x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": 8,
   "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": 9,
   "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": 10,
   "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": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "_X= np.random.rand(1, 2, 3, 4)\n",
    "X = tf.convert_to_tensor(_X)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q7. Multiply X by Y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q8. Multiply X and Y. The first axis represents batches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 94 100]\n",
      "  [229 244]]\n",
      "\n",
      " [[508 532]\n",
      "  [697 730]]]\n"
     ]
    }
   ],
   "source": [
    "_X = np.arange(1, 13, dtype=np.int32).reshape((2, 2, 3))\n",
    "_Y = np.arange(13, 25, dtype=np.int32).reshape((2, 3, 2))\n",
    "X = tf.convert_to_tensor(_X)\n",
    "Y = tf.convert_to_tensor(_Y)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q9. Compute the determinant of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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": 16,
   "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",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q11. Get the lower-trianglular in the Cholesky decomposition of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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": 18,
   "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": 19,
   "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",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reduction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q14. Predict the results of these."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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",
    "    else:\n",
    "        print(\"->\", out.eval())\n",
    "# If you remove the common suffix \"reduce_\", you will get the same \n",
    "# result in numpy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q15. Predict the results of these."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "_X = np.array([[True, True],\n",
    "              [False, False]], np.bool)\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",
    "    else:\n",
    "        print(\"->\", out.eval())\n",
    "\n",
    "# If you remove the common suffix \"reduce_\", you will get the same \n",
    "# result in numpy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Q16. Predict the results of these."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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",
    "\n",
    "# tf.count_nonzero == np.count_nonzero"
   ]
  },
  {
   "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": 23,
   "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(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": {
  "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
}