Chapter1_Tensors/Tensor_Transformations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tensor Transformations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import torch\n",
    "import numpy as np"
   ]
  },
  {
   "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",
    "* _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. Convert a torch Tensor `X` to numpy array `_X`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "X = torch.randn(3,2,1)\n",
    "_X = ...\n",
    "print(type(_X))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Convert a torch Tensor X to a python list Y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'list'>\n"
     ]
    }
   ],
   "source": [
    "X = torch.randn(3,2,1)\n",
    "Y = ...\n",
    "print(type(Y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q3. Convert the data type of X to float32."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X=> torch.IntTensor\n",
      "Y=> torch.FloatTensor\n"
     ]
    }
   ],
   "source": [
    "X = torch.IntTensor(3, 2).fill_(0)\n",
    "print(\"X=>\", X.type())\n",
    "Y = ...\n",
    "print(\"Y=>\", Y.type())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q4. Convert the data type of X to int32."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X=> torch.LongTensor\n",
      "Y=> torch.IntTensor\n"
     ]
    }
   ],
   "source": [
    "X = torch.LongTensor(3, 2).fill_(0)\n",
    "print(\"X=>\", X.type())\n",
    "Y = ...\n",
    "print(\"Y=>\", Y.type())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Size and Resize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5. Get the size and type of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "size= torch.Size([3, 2, 1])\n",
      "type= torch.FloatTensor\n"
     ]
    }
   ],
   "source": [
    "X = torch.randn(3, 2, 1)\n",
    "y = ...\n",
    "tp = ...\n",
    "print(\"size=\", y)\n",
    "print(\"type=\", tp)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q6. Get the total number of elements in X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "X = torch.randn(3, 2, 1)\n",
    "y = ...\n",
    "print(y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q7. Get the number of dimensions of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "X = torch.randn(3, 2, 1)\n",
    "y = ...\n",
    "print(y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q8. Resize X to (10, 3)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 3])\n"
     ]
    }
   ],
   "source": [
    "X = torch.ones(5, 6)\n",
    "Y = ...\n",
    "print(Y.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q9. Remove all the dimensions of size 1 in X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 10])\n"
     ]
    }
   ],
   "source": [
    "X = torch.randn(10, 10, 1, 1)\n",
    "Y = ...\n",
    "\n",
    "print(Y.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q10. Remove only the third dimension in X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 10, 1])\n"
     ]
    }
   ],
   "source": [
    "X = torch.randn(10, 10, 1, 1)\n",
    "Y = ...\n",
    "\n",
    "print(Y.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q11. Add a dimension of 1 at the end of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 10, 3, 1])\n"
     ]
    }
   ],
   "source": [
    "X = torch.ones(10, 10, 3)\n",
    "Y = ...\n",
    "print(Y.size())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing, Slicing, Joining, Mutating Ops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q12. Return the columns of indices y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    1     2     3     4     5     6     7\n",
      "    8     9    10    11    12    13    14\n",
      "   15    16    17    18    19    20    21\n",
      "[torch.FloatTensor of size 3x7]\n",
      "\n",
      "\n",
      "  1   3   5   6\n",
      "  8  10  12  13\n",
      " 15  17  19  20\n",
      "[torch.FloatTensor of size 3x4]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "X = torch.arange(1, 22).resize_(3, 7)\n",
    "print(X)\n",
    "y = torch.LongTensor([0, 2, 4, 5])\n",
    "\n",
    "print(...)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q13. Apply `mask` to `x`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x= \n",
      "  1\n",
      "  2\n",
      "  3\n",
      "  4\n",
      "  5\n",
      "  6\n",
      "  7\n",
      "  8\n",
      "  9\n",
      " 10\n",
      "[torch.FloatTensor of size 10]\n",
      "\n",
      "masked= \n",
      "  6\n",
      "  7\n",
      "  8\n",
      "  9\n",
      " 10\n",
      "[torch.FloatTensor of size 5]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = torch.arange(1, 11)\n",
    "print(\"x=\", x)\n",
    "mask = x.gt(5)\n",
    "print(\"masked=\", ...)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q14. Split X into 5 same-sized tensors along the second dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X= \n",
      "  1   2   3   4   5\n",
      "  6   7   8   9  10\n",
      "[torch.FloatTensor of size 2x5]\n",
      "\n",
      "Chunks= (\n",
      " 1\n",
      " 6\n",
      "[torch.FloatTensor of size 2x1]\n",
      ", \n",
      " 2\n",
      " 7\n",
      "[torch.FloatTensor of size 2x1]\n",
      ", \n",
      " 3\n",
      " 8\n",
      "[torch.FloatTensor of size 2x1]\n",
      ", \n",
      " 4\n",
      " 9\n",
      "[torch.FloatTensor of size 2x1]\n",
      ", \n",
      "  5\n",
      " 10\n",
      "[torch.FloatTensor of size 2x1]\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "X = torch.arange(1, 11).resize_(2, 5)\n",
    "print(\"X=\", X)\n",
    "Ys = ...\n",
    "print(\"Chunks=\", Ys)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q15. Split X into same-sized tensors along the second dimension such that each has the size 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X= \n",
      "  1   2   3   4   5\n",
      "  6   7   8   9  10\n",
      "[torch.FloatTensor of size 2x5]\n",
      "\n",
      "Split= (\n",
      " 1\n",
      " 6\n",
      "[torch.FloatTensor of size 2x1]\n",
      ", \n",
      " 2\n",
      " 7\n",
      "[torch.FloatTensor of size 2x1]\n",
      ", \n",
      " 3\n",
      " 8\n",
      "[torch.FloatTensor of size 2x1]\n",
      ", \n",
      " 4\n",
      " 9\n",
      "[torch.FloatTensor of size 2x1]\n",
      ", \n",
      "  5\n",
      " 10\n",
      "[torch.FloatTensor of size 2x1]\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "X = torch.arange(1, 11).resize_(2, 5)\n",
    "print(\"X=\", X)\n",
    "Ys = ...\n",
    "print(\"Split=\", Ys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q16. Remove the second dimension of X and return all resulting slices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X= \n",
      "  1   2   3   4   5\n",
      "  6   7   8   9  10\n",
      "[torch.FloatTensor of size 2x5]\n",
      "\n",
      "Sliced tensors= (\n",
      " 1\n",
      " 6\n",
      "[torch.FloatTensor of size 2]\n",
      ", \n",
      " 2\n",
      " 7\n",
      "[torch.FloatTensor of size 2]\n",
      ", \n",
      " 3\n",
      " 8\n",
      "[torch.FloatTensor of size 2]\n",
      ", \n",
      " 4\n",
      " 9\n",
      "[torch.FloatTensor of size 2]\n",
      ", \n",
      "  5\n",
      " 10\n",
      "[torch.FloatTensor of size 2]\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "X = torch.arange(1, 11).resize_(2, 5)\n",
    "print(\"X=\", X)\n",
    "ys = ...\n",
    "print(\"Sliced tensors=\", ys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q17. Stack x, y, and z vertically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 1  4\n",
      " 2  5\n",
      " 3  6\n",
      "[torch.FloatTensor of size 3x2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "x = torch.Tensor([1, 4])\n",
    "y = torch.Tensor([2, 5])\n",
    "z = torch.Tensor([3, 6])\n",
    "\n",
    "O = ...\n",
    "print(O)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q18. Repeat X 1 and 2 times along each dimension ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X= \n",
      " 1  2  3\n",
      " 4  5  6\n",
      "[torch.FloatTensor of size 2x3]\n",
      "\n",
      "Repeated= \n",
      " 1  2  3  1  2  3\n",
      " 4  5  6  4  5  6\n",
      "[torch.FloatTensor of size 2x6]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "X = torch.arange(1, 7).resize_(2, 3)\n",
    "print(\"X=\", X)\n",
    "Y = ...\n",
    "print(\"Repeated=\", Y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q19. Concatenate X and Y along the first dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "  1   2   3\n",
      "  4   5   6\n",
      "  7   8   9\n",
      " 10  11  12\n",
      "[torch.FloatTensor of size 4x3]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "X = torch.Tensor([[1, 2, 3], [4, 5, 6]])\n",
    "Y = torch.Tensor([[7, 8, 9], [10, 11, 12]])\n",
    "Z = ...\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q20. Swap the first and second dimension of X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X= \n",
      "-0.2717 -0.5849\n",
      " 1.4468  0.4441\n",
      " 1.1451  1.3460\n",
      "[torch.FloatTensor of size 3x2]\n",
      "\n",
      "Transposed= \n",
      "-0.2717  1.4468  1.1451\n",
      "-0.5849  0.4441  1.3460\n",
      "[torch.FloatTensor of size 2x3]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "X = torch.randn(3, 2)\n",
    "print(\"X=\", X)\n",
    "Y = ...\n",
    "print(\"Transposed=\", Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q21. Permute X's dimensions such that the new tensor has shape (3, 1, 2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 1, 2])\n"
     ]
    }
   ],
   "source": [
    "X = torch.ones(1, 2, 3)\n",
    "Y = ...\n",
    "print(Y.size())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sorting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q22. Sort X along the second dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X= \n",
      " 1  4\n",
      " 3  1\n",
      "[torch.FloatTensor of size 2x2]\n",
      "\n",
      "sorted tensor= \n",
      " 1  4\n",
      " 1  3\n",
      "[torch.FloatTensor of size 2x2]\n",
      "\n",
      "sorted indices= \n",
      " 0  1\n",
      " 1  0\n",
      "[torch.LongTensor of size 2x2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "X = torch.Tensor([[1,4],[3,1]])\n",
    "print(\"X=\", X)\n",
    "sorted_tensor, sorted_indices = ...\n",
    "print(\"sorted tensor=\", sorted_tensor)\n",
    "print(\"sorted indices=\", sorted_indices)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Counting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q23. Get the indices of all nonzero elements in X."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " 0  1\n",
      " 0  2\n",
      " 1  0\n",
      " 1  3\n",
      " 1  4\n",
      "[torch.LongTensor of size 5x2]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "X = torch.Tensor([[0,1,7,0,0],[3,0,0,2,19]])\n",
    "y = ...\n",
    "print(y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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
}