Chapter1_Tensors/Linear_Algebra.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Linear Algebra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import torch\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.date(2017, 9, 26)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import date\n",
    "date.today()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "author = \"kyubyong. https://github.com/Kyubyong/pytorch_exercises\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.2.0_3'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.13.0'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NOTE on notation\n",
    "\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 and vector products"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Compute the inner product of two vectors x and y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11.0\n"
     ]
    }
   ],
   "source": [
    "x = torch.Tensor([1, 2])\n",
    "y = torch.Tensor([3, 4])\n",
    "z = ...\n",
    "\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Compute the product of vector x and matrix Y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 2\n",
      " 2\n",
      "[torch.FloatTensor of size 2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = torch.Tensor([1, 2])\n",
    "Y = torch.Tensor([[0, 0], [1, 1]])\n",
    "z = ...\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q3. Compute a matrix-vector product of matrix X and vector y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 11\n",
      " 25\n",
      "[torch.FloatTensor of size 2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "X = torch.Tensor([[1, 2], [3, 4]])\n",
    "y = torch.Tensor([3, 4])\n",
    "z = ...\n",
    "print(z)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q4. Compute a matrix multiplication of matrix X and Y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 2  2\n",
      " 4  4\n",
      "[torch.FloatTensor of size 2x2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "X = torch.Tensor([[1, 2], [3, 4]])\n",
    "Y = torch.Tensor([[0, 0], [1, 1]])\n",
    "Z = ...\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5. Compute a batch matrix multiplication of tensor X and Y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 4, 6])\n"
     ]
    }
   ],
   "source": [
    "X = torch.randn(3, 4, 5)\n",
    "Y = torch.randn(3, 5, 6)\n",
    "Z = ...\n",
    "print(Z.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q6. Express the below computation as a single line.<br>\n",
    "`M + x⊗y`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 4  5\n",
      " 7  9\n",
      "[torch.FloatTensor of size 2x2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = torch.Tensor([1, 2])\n",
    "y = torch.Tensor([3, 4])\n",
    "M = torch.ones(2, 2)\n",
    "Z = ...\n",
    "\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q7.Express the below computation as a single line.<br>\n",
    "`m + torch.mv(X, y)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 12\n",
      " 26\n",
      "[torch.FloatTensor of size 2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "X = torch.Tensor([[1, 2], [3, 4]])\n",
    "y = torch.Tensor([3, 4])\n",
    "m = torch.ones(2)\n",
    "Z = ...\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q8.Express the below computation as a single line.<br/>\n",
    "`M + torch.mm(X, Y)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 3  3\n",
      " 5  5\n",
      "[torch.FloatTensor of size 2x2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "X = torch.Tensor([[1, 2], [3, 4]])\n",
    "Y = torch.Tensor([[0, 0], [1, 1]])\n",
    "M = torch.ones(2, 2)\n",
    "Z = ...\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q9. Express the below computation as a single line.<br/>\n",
    "``M + torch.sum(torch.bmm(X, Y), 0)``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "-0.3284  1.0236 -0.3820 -1.3869  0.8295\n",
      "-7.2099 -2.7595  1.6010  6.4944  1.4375\n",
      "-3.2925 -8.0896  0.9989 -0.1702  3.2710\n",
      "[torch.FloatTensor of size 3x5]\n",
      " torch.Size([3, 5])\n"
     ]
    }
   ],
   "source": [
    "X = torch.randn(10, 3, 4)\n",
    "Y = torch.randn(10, 4, 5)\n",
    "M = torch.ones(3, 5)\n",
    "Z = ...\n",
    "print(Z, Z.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q10. Express the below computation as a single line.<br>\n",
    "`M + torch.bmm(X, Y)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 3, 5])\n"
     ]
    }
   ],
   "source": [
    "X = torch.randn(10, 3, 4)\n",
    "Y = torch.randn(10, 4, 5)\n",
    "M = torch.ones(3, 5)\n",
    "Z = ...\n",
    "print(Z.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decompositions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q11. Compute the upper trianglular `U` in the Cholesky decomposition of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 2  6 -8\n",
      " 0  1  5\n",
      " 0  0  3\n",
      "[torch.FloatTensor of size 3x3]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[4, 12, -16], [12, 37, -43], [-16, -43, 98]], dtype=np.float32)\n",
    "X = torch.from_numpy(_X)\n",
    "U = ...\n",
    "print(U)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q12. Compute the qr factorization of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "q= \n",
      "-0.8571  0.3943  0.3314\n",
      "-0.4286 -0.9029 -0.0343\n",
      " 0.2857 -0.1714  0.9429\n",
      "[torch.FloatTensor of size 3x3]\n",
      "\n",
      "r= \n",
      " -14.0000  -21.0000   14.0000\n",
      "   0.0000 -175.0000   70.0000\n",
      "   0.0000    0.0000  -35.0000\n",
      "[torch.FloatTensor of size 3x3]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[12, -51, 4], [6, 167, -68], [-4, 24, -41]], dtype=np.float32)\n",
    "X = torch.from_numpy(_X)\n",
    "q, r = ...\n",
    "print(\"q=\", q)\n",
    "print(\"r=\", r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q13. Factor x by Singular Value Decomposition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "U= \n",
      " 0  1  0  0\n",
      " 1  0  0  0\n",
      "-0  0  0 -1\n",
      "-0  0  1  0\n",
      "[torch.FloatTensor of size 4x4]\n",
      "\n",
      "s= \n",
      " 3.0000\n",
      " 2.2361\n",
      " 2.0000\n",
      " 0.0000\n",
      "[torch.FloatTensor of size 4]\n",
      "\n",
      "V= \n",
      "-0.0000  0.4472 -0.0000  0.0000\n",
      "-0.0000  0.0000  1.0000  0.0000\n",
      " 1.0000  0.0000 -0.0000  0.0000\n",
      " 0.0000  0.0000  0.0000  1.0000\n",
      " 0.0000  0.8944  0.0000 -0.0000\n",
      "[torch.FloatTensor of size 5x4]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "_X = np.array([[1, 0, 0, 0, 2], [0, 0, 3, 0, 0], [0, 0, 0, 0, 0], [0, 2, 0, 0, 0]], dtype=np.float32)\n",
    "X = torch.from_numpy(_X)\n",
    "U, s, V = ...\n",
    "print(\"U=\", U)\n",
    "print(\"s=\", s)\n",
    "print(\"V=\", V)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix eigenvalues"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q14. Compute the eigenvalues and right eigenvectors of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eigen values= \n",
      " 11   0\n",
      "  1   0\n",
      "  2   0\n",
      "[torch.FloatTensor of size 3x2]\n",
      "\n",
      "eigen vectors= \n",
      " 0.0000  0.0000  1.0000\n",
      " 0.4472  0.8944  0.0000\n",
      " 0.8944 -0.4472  0.0000\n",
      "[torch.FloatTensor of size 3x3]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "X = torch.Tensor([[2, 0, 0], [0, 3, 4], [0, 4, 9]])\n",
    "e, v = ...\n",
    "print(\"eigen values=\", e)\n",
    "print(\"eigen vectors=\", v)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Norms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q15. Calculate the L2 norm of x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.21954445729\n"
     ]
    }
   ],
   "source": [
    "x = torch.arange(-5, 5)\n",
    "y = ...\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q16. Calculate the L1 norm of x."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25.0\n"
     ]
    }
   ],
   "source": [
    "x = torch.arange(-5, 5)\n",
    "y = ...\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inverting matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q17. Compute the inverse of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "-2.0000  1.0000\n",
      " 1.5000 -0.5000\n",
      "[torch.FloatTensor of size 2x2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "X = torch.Tensor([[1, 2], [3, 4]])\n",
    "Y = ...\n",
    "print(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}