PyTorch101 - Part 1 - Using Tensors.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PyTorch 101 tutorial - Using tensors\n",
    "Just a simple tutorial on tensors and stuff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4.0\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "print(torch.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Declaring tensors\n",
    "\n",
    "First, we need to declare a tensor. There are different ways depending on the initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Empty tensor, uncleaned values\n",
    "x = torch.empty(5, 3)\n",
    "# Random values (uniform [0,1] probably)\n",
    "x = torch.rand(5, 3)\n",
    "# Zeros, fixing dtype\n",
    "x = torch.zeros(5, 3, dtype=torch.long)\n",
    "# Tensor from data\n",
    "x = torch.tensor([5.5, 3])\n",
    "# Redeclaring tensor \n",
    "x = x.new_ones(5, 3, dtype=torch.double)\n",
    "# New tensor from existing\n",
    "x = torch.randn_like(x, dtype=torch.float)\n",
    "# Get the value from a 1-value tensor\n",
    "x = torch.randn(1)\n",
    "_ = x.item()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also read properties of tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1])\n",
      "torch.float32\n"
     ]
    }
   ],
   "source": [
    "# Get size\n",
    "print(x.size())\n",
    "# Get dtype\n",
    "print(x.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic ops\n",
    "\n",
    "Next, we want to perform basic operations on tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 1.7238,  1.2403,  1.2056],\n",
       "        [ 0.8910,  1.2602,  0.8987],\n",
       "        [ 0.9470,  1.1495,  0.5105],\n",
       "        [ 0.6981,  0.8808,  0.9359],\n",
       "        [ 1.3978,  1.1756,  0.3888]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y = torch.rand(5, 3), torch.rand(5, 3)\n",
    "# Add tensors\n",
    "z = x + y\n",
    "# We can also use torch.add and use the out parameter\n",
    "z = torch.empty(5, 3)\n",
    "torch.add(x, y, out=z)\n",
    "# Last, we can use in-place addition\n",
    "y.add_(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that any operation using _ is in-place and will modify the calling object. \n",
    "Also, torch tensors can use numpy indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 1.2403,  1.2602,  1.1495,  0.8808,  1.1756])\n"
     ]
    }
   ],
   "source": [
    "print(y[:, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reshaping tensors is quite straight-forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([16]) torch.Size([2, 8])\n"
     ]
    }
   ],
   "source": [
    "x = torch.randn(4, 4)\n",
    "# Reshaping to fixed size\n",
    "y = x.view(16)\n",
    "# Reshaping to unconstrained size\n",
    "z = x.view(-1, 8)\n",
    "print(y.size(), z.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other basic operations on tensors are declared in the documentation\n",
    "\n",
    "## Numpy integration\n",
    "PyTorch works seamlessly with numpy, providing an updated numpy version of tensors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1.]\n",
      " [1. 1.]]\n",
      "tensor([[ 2.,  2.],\n",
      "        [ 2.,  2.]])\n",
      "[[2. 2.]\n",
      " [2. 2.]]\n",
      "tensor([[ 0.,  0.],\n",
      "        [ 0.,  0.]], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Get the numpy vector\n",
    "a = torch.ones(2, 2)\n",
    "b = a.numpy()\n",
    "print(b)\n",
    "\n",
    "# Perform addition on a to see changes\n",
    "a.add_(a)\n",
    "print(a)\n",
    "print(b)\n",
    "\n",
    "# From numpy back to torch\n",
    "c = np.zeros([2, 2])\n",
    "d = torch.from_numpy(c)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cuda integration\n",
    "We can run all these operations in a GPU device, also checking if it is available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No GPU buddy\n"
     ]
    }
   ],
   "source": [
    "# let us run this cell only if CUDA is available\n",
    "# We will use ``torch.device`` objects to move tensors in and out of GPU\n",
    "if torch.cuda.is_available():\n",
    "    device = torch.device(\"cuda\")          # a CUDA device object\n",
    "    y = torch.ones_like(x, device=device)  # directly create a tensor on GPU\n",
    "    x = x.to(device)                       # or just use strings ``.to(\"cuda\")``\n",
    "    z = x + y\n",
    "    print(z)\n",
    "    print(z.to(\"cpu\", torch.double))       # ``.to`` can also change dtype together!\n",
    "else:\n",
    "    print(\"No GPU buddy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Farewell\n",
    "This was the first part of the PyTorch tutorial in which we try to understand to handle tensors, applying operations and reshaping them.\n",
    "\n",
    "Next we are going to experiment with the autograd "
   ]
  }
 ],
 "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}