tensor_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "什么是PyTorch?\n",
    "================\n",
    "\n",
    "这是一个基于Python的科学计算包，其旨在服务两类场合\n",
    "\n",
    "- 替代numpy发挥GPU潜能\n",
    "- 一个提供了高度灵活性和效率的深度学习实验性平台\n",
    "\n",
    "\n",
    "开始\n",
    "---------------\n",
    "\n",
    "Tensors\n",
    "\n",
    "\n",
    "Tensors和numpy中的ndarrays较为相似, 与此同时Tensor也能够使用GPU来加速运算。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import torch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "构建一个未初始化的5*3矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.0000e+00,  0.0000e+00,  1.3733e-42],\n",
      "        [ 0.0000e+00,  7.0065e-45,  0.0000e+00],\n",
      "        [ 7.6238e+08,  5.4230e-43,  0.0000e+00],\n",
      "        [ 0.0000e+00,  9.1843e-41,  0.0000e+00],\n",
      "        [ 8.8743e+08,  5.4230e-43,  0.0000e+00]])\n"
     ]
    }
   ],
   "source": [
    "x = torch.empty(5, 3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "构建一个随机初始化的矩阵\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.3033,  0.0005,  0.7131],\n",
      "        [ 0.8024,  0.8223,  0.2878],\n",
      "        [ 0.4480,  0.9465,  0.3888],\n",
      "        [ 0.0029,  0.6421,  0.7353],\n",
      "        [ 0.2377,  0.2970,  0.5093]])\n"
     ]
    }
   ],
   "source": [
    "x = torch.rand(5, 3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "构建一个0矩阵，数据类型为long\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0,  0,  0],\n",
      "        [ 0,  0,  0],\n",
      "        [ 0,  0,  0],\n",
      "        [ 0,  0,  0],\n",
      "        [ 0,  0,  0]])\n"
     ]
    }
   ],
   "source": [
    "x = torch.zeros(5, 3, dtype=torch.long)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "直接从数据中构建tensor\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 5.5000,  3.0000])\n"
     ]
    }
   ],
   "source": [
    "x = torch.tensor([5.5, 3])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "或者是基于已经存在的tensor创建tensor。这些方法会复用输入张量的属性，比如dtype，除非用户提供了新的值。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 1.,  1.,  1.],\n",
      "        [ 1.,  1.,  1.],\n",
      "        [ 1.,  1.,  1.],\n",
      "        [ 1.,  1.,  1.],\n",
      "        [ 1.,  1.,  1.]], dtype=torch.float64)\n",
      "tensor([[ 0.0530, -0.8755, -0.8630],\n",
      "        [ 0.0889,  0.7886,  0.1081],\n",
      "        [-1.2099, -0.1259,  0.4774],\n",
      "        [ 0.1187,  0.0942,  0.7791],\n",
      "        [-1.7884, -1.2375,  1.8421]])\n"
     ]
    }
   ],
   "source": [
    "x = x.new_ones(5, 3, dtype=torch.double)      # new_* 的方法输入是size\n",
    "print(x)\n",
    "\n",
    "x = torch.randn_like(x, dtype=torch.float)    # 重写dtype\n",
    "print(x)                                      # 结果有相同的size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "获取它的size\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([5, 3])\n"
     ]
    }
   ],
   "source": [
    "print(x.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\"><h4>注意</h4><p>``torch.Size`` 实际上是一个tuple，所以它支持所有的tuple操作</p></div>\n",
    "\n",
    "\n",
    "Operations\n",
    "---------------\n",
    "操作有多种语法。在下面的示例中，我们将查看加法操作。\n",
    "\n",
    "\n",
    "加法：语法1\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.2156, -0.7562, -0.0616],\n",
      "        [ 0.8738,  1.7374,  0.5208],\n",
      "        [-0.4377,  0.4482,  0.5068],\n",
      "        [ 0.8632,  0.8912,  1.5788],\n",
      "        [-1.3056, -0.4241,  2.2794]])\n"
     ]
    }
   ],
   "source": [
    "y = torch.rand(5, 3)\n",
    "print(x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "加法：语法2\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.2156, -0.7562, -0.0616],\n",
      "        [ 0.8738,  1.7374,  0.5208],\n",
      "        [-0.4377,  0.4482,  0.5068],\n",
      "        [ 0.8632,  0.8912,  1.5788],\n",
      "        [-1.3056, -0.4241,  2.2794]])\n"
     ]
    }
   ],
   "source": [
    "print(torch.add(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "加法：提供一个额外的参数作为输出\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "result = torch.empty(5, 3)\n",
    "torch.add(x, y, out=result)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "加法: 原地操作\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# adds x to y\n",
    "y.add_(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\"><h4>注意</h4><p>任何使张量就地改变的变形的操作都是用 ``_``结尾的.\n",
    "    例如: ``x.copy_(y)``, ``x.t_()`` 会改变 ``x``.</p></div>\n",
    "\n",
    "你可以使用标准的NumPy索引来访问张量。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(x[:, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "变形： 如果你想要 resize/reshape 张量, 你可以使用 ``torch.view``:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = torch.randn(4, 4)\n",
    "y = x.view(16)\n",
    "z = x.view(-1, 8)  # 尺寸 -1 是从其他维度推断出来的\n",
    "print(x.size(), y.size(), z.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果你有一个单元素张量，使用 ``.item()`` 来获得其作为python的数字类型\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = torch.randn(1)\n",
    "print(x)\n",
    "print(x.item())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**进一步阅读:**\n",
    "\n",
    "\n",
    "  100+ Tensor的操作，包括换位、索引、切片、数学运算、线性算法和随机数等等\n",
    "  \n",
    "  详见[http://pytorch.org/docs/torch](http://pytorch.org/docs/torch).\n",
    "\n",
    "NumPy Bridge\n",
    "------------\n",
    "\n",
    "Torch Tensor和 NumPy array 的转换是非常容易的。\n",
    "\n",
    "注意Torch的Tensor和numpy数组是共享存储空间的，修改一个会导致另外的一个也被修改。\n",
    "\n",
    "将tensor转换为numpy数组\n",
    "------------\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 1.,  1.,  1.,  1.,  1.])\n"
     ]
    }
   ],
   "source": [
    "a = torch.ones(5)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.  1.  1.  1.  1.]\n"
     ]
    }
   ],
   "source": [
    "b = a.numpy()\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See how the numpy array changed in value.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([ 2.,  2.,  2.,  2.,  2.])\n",
      "[ 2.  2.  2.  2.  2.]\n"
     ]
    }
   ],
   "source": [
    "a.add_(1)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将numpy 数组转换为tensor\n",
    "------------------------\n",
    "注意更改numpy数组如何自动更改Tensor\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2.  2.  2.  2.  2.]\n",
      "tensor([ 2.,  2.,  2.,  2.,  2.], dtype=torch.float64)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "a = np.ones(5)\n",
    "b = torch.from_numpy(a)\n",
    "np.add(a, 1, out=a)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除了CharTensor，CPU上所有的Tensor都支持转换为numpy数组返回\n",
    "\n",
    "CUDA 张量\n",
    "------------\n",
    "\n",
    "Tensors 可以使用 ``.to`` 方法移动到任意设备上.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 1.0530,  0.1245,  0.1370],\n",
      "        [ 1.0889,  1.7886,  1.1081],\n",
      "        [-0.2099,  0.8741,  1.4774],\n",
      "        [ 1.1187,  1.0942,  1.7791],\n",
      "        [-0.7884, -0.2375,  2.8421]], device='cuda:0')\n",
      "tensor([[ 1.0530,  0.1245,  0.1370],\n",
      "        [ 1.0889,  1.7886,  1.1081],\n",
      "        [-0.2099,  0.8741,  1.4774],\n",
      "        [ 1.1187,  1.0942,  1.7791],\n",
      "        [-0.7884, -0.2375,  2.8421]], dtype=torch.float64)\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\")          # 一个 CUDA 设备对象\n",
    "    y = torch.ones_like(x, device=device)  # 直接构建一个在GPU上的Tensor\n",
    "    x = x.to(device)                       # 或者直接使用字符串 ``.to(\"cuda\")``\n",
    "    z = x + y\n",
    "    print(z)\n",
    "    print(z.to(\"cpu\", torch.double))       # ``.to`` 也可以一起改变dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}