pytorch/tensor_tutorial1.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "\nTensors\n=======\n\nTensors behave almost exactly the same way in PyTorch as they do in\nTorch.\n\nCreate a tensor of size (5 x 7) with uninitialized memory:\n\n\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "import torch\na = torch.FloatTensor(5, 7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Initialize a tensor randomized with a normal distribution with mean=0, var=1:\n\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "a = torch.randn(5, 7)\nprint(a)\nprint(a.size())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<div class=\"alert alert-info\"><h4>Note</h4><p>``torch.Size`` is in fact a tuple, so it supports the same operations</p></div>\n\nInplace / Out-of-place\n----------------------\n\nThe first difference is that ALL operations on the tensor that operate\nin-place on it will have an ``_`` postfix. For example, ``add`` is the\nout-of-place version, and ``add_`` is the in-place version.\n\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "a.fill_(3.5)\n# a has now been filled with the value 3.5\n\nb = a.add(4.0)\n# a is still filled with 3.5\n# new tensor b is returned with values 3.5 + 4.0 = 7.5\n\nprint(a, b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Some operations like ``narrow`` do not have in-place versions, and\nhence, ``.narrow_`` does not exist. Similarly, some operations like\n``fill_`` do not have an out-of-place version, so ``.fill`` does not\nexist.\n\nZero Indexing\n-------------\n\nAnother difference is that Tensors are zero-indexed. (In lua, tensors are\none-indexed)\n\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "b = a[0, 3]  # select 1st row, 4th column from a"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Tensors can be also indexed with Python's slicing\n\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "b = a[:, 3:5]  # selects all rows, 4th column and  5th column from a"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "No camel casing\n---------------\n\nThe next small difference is that all functions are now NOT camelCase\nanymore. For example ``indexAdd`` is now called ``index_add_``\n\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "x = torch.ones(5, 5)\nprint(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "z = torch.Tensor(5, 2)\nz[:, 0] = 10\nz[:, 1] = 100\nprint(z)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "x.index_add_(1, torch.LongTensor([4, 0]), z)\nprint(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Numpy Bridge\n------------\n\nConverting a torch Tensor to a numpy array and vice versa is a breeze.\nThe torch Tensor and numpy array will share their underlying memory\nlocations, and changing one will change the other.\n\nConverting torch Tensor to numpy Array\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "a = torch.ones(5)\nprint(a)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "b = a.numpy()\nprint(b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "a.add_(1)\nprint(a)\nprint(b) \t# see how the numpy array changed in value"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Converting numpy Array to torch Tensor\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "import numpy as np\na = np.ones(5)\nb = torch.from_numpy(a)\nnp.add(a, 1, out=a)\nprint(a)\nprint(b)  # see how changing the np array changed the torch Tensor automatically"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "All the Tensors on the CPU except a CharTensor support converting to\nNumPy and back.\n\nCUDA Tensors\n------------\n\nCUDA Tensors are nice and easy in pytorch, and transfering a CUDA tensor\nfrom the CPU to GPU will retain its underlying type.\n\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": false
      },
      "outputs": [],
      "source": [
        "# let us run this cell only if CUDA is available\nif torch.cuda.is_available():\n    # creates a LongTensor and transfers it\n    # to GPU as torch.cuda.LongTensor\n    a = torch.LongTensor(10).fill_(3).cuda()\n    print(type(a))\n    b = a.cpu()\n    # transfers it to CPU, back to\n    # being a torch.LongTensor"
      ]
    }
  ],
  "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.1"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}