jupyter/pytorch-tutorials/ch1_tensor.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Nguồn : https://pytorch.org/tutorials/beginner/blitz/tensor_tutorial.html#sphx-glr-beginner-blitz-tensor-tutorial-py\n",
    "\n",
    "\n",
    "PyTorch là gì?\n",
    "================\n",
    "\n",
    "PyTorch là thư viện tính toán xây dựng trên nền tảng ngôn ngữ Python. PyTorch nhắm vào hai mục tiêu chính \n",
    "\n",
    "- Hỗ trợ tính toán khoa học, thay thế cho thư viện NumPy (một thư viện Python hỗ trợ tính toán khoa học trên mảng nhiều chiều) và hỗ trợ GPU\n",
    "- Trở thành một nền tảng Deep Learning linh hoạt và hiệu quả\n",
    "\n",
    "PyTorch được phát triển bởi Facebook (https://pytorch.org/) và là một thư viện mã nguồn mở (https://github.com/pytorch/pytorch)\n",
    "\n",
    "Giới thiệu\n",
    "---------------\n",
    "\n",
    "Tensor\n",
    "^^^^^^^\n",
    "\n",
    "Trong ngữ cảnh các thư viện tính toán, Tensor có thể hiểu như là mảng nhiều chiều (giống như ndarray của thư viện NumPy). Tensor là sự tổng quát hoá của vector (mảng 1 chiều), ma trận (mảng 2 chiều). Tensor của PyTorch có thêm một lợi thế là có hỗ trợ tính toán trên GPU để tăng tốc độ.\n",
    "\n",
    "\n",
    "Cài đặt\n",
    "---------------\n",
    "Cài đặt anaconda sau đó chạy lệnh\n",
    "\n",
    "`conda install pytorch torchvision -c pytorch`\n",
    "\n",
    "Chạy `jupyter notebook` để mở notebook này tương tác\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Các hỗ trợ cơ bản về Tensor nằm trong module `torch`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import torch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Định nghĩa một ma trận 5x3, chưa khởi tạo giá trị:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.0000e+00, -2.0000e+00, -1.6168e-21],\n",
      "        [ 2.8643e-42,  7.1801e+28,  2.5958e-06],\n",
      "        [ 7.3983e+31,  2.7691e+20,  1.0645e+24],\n",
      "        [ 5.5603e+31,  4.2964e+24,  1.5842e-10],\n",
      "        [ 3.9831e-11,  1.6925e-41,  2.5031e-37]])\n"
     ]
    }
   ],
   "source": [
    "x = torch.empty(5, 3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Định nghĩa một ma trận 5x3 được khởi tạo ngẫu nhiên:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.rand(5, 3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Định nghĩa một ma trận 5x3 khởi tạo với giá trị 0, kiểu dữ liệu (dtype) là long:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.zeros(5, 3, dtype=torch.long)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Khởi tạo tensor trực tiếp từ số liệu:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = torch.tensor([5.5, 3])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Khởi tạo tensor từ một tensor sẵn có. Các phương thức khởi tạo này sẽ dùng lại các thuộc tính của tensor đầu vào (như là dtype) trừ khi người dùng cung cấp giá trị mới cho các thuộc tính.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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([[-1.4884,  2.4420,  0.7131],\n",
      "        [ 2.2873, -0.3993, -0.0366],\n",
      "        [-1.8804, -0.4695,  0.4877],\n",
      "        [ 0.1583,  0.4593,  0.1510],\n",
      "        [-0.1133, -1.4087,  1.6926]])\n"
     ]
    }
   ],
   "source": [
    "x = x.new_ones(5, 3, dtype=torch.double)      # new_* methods take in sizes\n",
    "print(x)\n",
    "\n",
    "x = torch.randn_like(x, dtype=torch.float)    # override dtype!\n",
    "print(x)                                      # result has the same size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trả về kích thước của tensor (nghĩa là tất cả kích thước của các chiều của mảng):\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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>Ghi chú</h4><p>``torch.Size`` là tuple trong Python nên sẽ hỗ trợ tất cả các phép tính thông dụng với tuple.</p></div>\n",
    "\n",
    "Phép toán\n",
    "^^^^^^^^^^\n",
    "Có nhiều cú pháp khác nhau để biểu diễn phép toán. Trong ví dụ sau ta sẽ xem xét phép toán cộng 2 tensor.\n",
    "\n",
    "Phép cộng: cú pháp thứ nhất\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 1., 1.],\n",
      "        [1., 1., 1.]])\n",
      "tensor([[3., 3., 3.],\n",
      "        [3., 3., 3.]])\n",
      "tensor([[4., 4., 4.],\n",
      "        [4., 4., 4.]])\n"
     ]
    }
   ],
   "source": [
    "x = torch.ones(2, 3)\n",
    "y = 3 * torch.ones(2, 3)\n",
    "print(x)\n",
    "print(y)\n",
    "print(x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Phép cộng: cú pháp thứ hai\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[4., 4., 4.],\n",
      "        [4., 4., 4.]])\n"
     ]
    }
   ],
   "source": [
    "print(torch.add(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Phép cộng: chỉ định trước tensor đầu ra\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[4., 4., 4.],\n",
      "        [4., 4., 4.]])\n"
     ]
    }
   ],
   "source": [
    "result = torch.empty(5, 3)\n",
    "torch.add(x, y, out=result)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Phép cộng tại chỗ (lưu ý việc tiết kiệm bộ nhớ là khá quan trọng để tăng hiệu quả tính toán)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[4., 4., 4.],\n",
      "        [4., 4., 4.]])\n"
     ]
    }
   ],
   "source": [
    "# Cộng x vào y\n",
    "y.add_(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\"><h4>Ghi chú</h4><p>Các phép toán nào mà thay đổi giá trị của tensor tại chỗ thì sẽ có tên kết thúc bởi dấu ``_``.\n",
    "    Ví dụ: ``x.copy_(y)``, ``x.t_()``, sẽ thay đổi giá trị của ``x``.</p></div>\n",
    "\n",
    "Bạn có thể tận dụng các cách truy cập theo chỉ số giống như NumPy! Ví dụ để in ra cột #1 của ma trận x:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1., 1.])\n"
     ]
    }
   ],
   "source": [
    "print(x[:, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thay đổi kích thước: nào muốn thay đổi kích thước Tensor, bạn có thể dùng ``torch.view``:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])\n"
     ]
    }
   ],
   "source": [
    "x = torch.randn(4, 4)\n",
    "y = x.view(16)\n",
    "z = x.view(-1, 8)  # -1 nghĩa là là kích thước sẽ được suy ra từ các chiều còn lại\n",
    "print(x.size(), y.size(), z.size())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tất nhiên khi dùng view, kích thước mới phải có số phần tử bằng số phần tử của Tensor. Ví dụ sau sẽ báo lỗi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "invalid argument 2: size '[14]' is invalid for input with 16 elements at /Users/soumith/miniconda2/conda-bld/pytorch_1532623076075/work/aten/src/TH/THStorage.cpp:84",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-29-66e035dcc596>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mview\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m14\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m: invalid argument 2: size '[14]' is invalid for input with 16 elements at /Users/soumith/miniconda2/conda-bld/pytorch_1532623076075/work/aten/src/TH/THStorage.cpp:84"
     ]
    }
   ],
   "source": [
    "y = x.view(14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nếu tensor chỉ có 1 phần tử thì có thể dùng ``.item()`` để truy cập giá trị duy nhất đó\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-0.0990])\n",
      "-0.09897159039974213\n"
     ]
    }
   ],
   "source": [
    "x = torch.randn(1)\n",
    "print(x)\n",
    "print(x.item())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Đọc thêm:**\n",
    "\n",
    "\n",
    "  Hơn 100+ phép toán trên Tensor, bao gồm transposing, indexing, slicing,\n",
    "  các phép tính toán học, đại số tuyến tính, số ngẫu nhiên, ...,\n",
    "  được mô tả tại\n",
    "  `<http://pytorch.org/docs/torch>`_.\n",
    "\n",
    "Tương tác với NumPy\n",
    "------------\n",
    "\n",
    "Chuyển đổi giữa PyTorch tensor và mảng NumPy rất dễ dàng.\n",
    "\n",
    "PyTorch tensor và mảng NumPy cùng chia sẻ bộ nhớ dữ liệu, thay đổi bên này thì bên kia cũng thay đổi theo.\n",
    "\n",
    "Chuyển từ Tensor về mảng NumPy\n",
    "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "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": 32,
   "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": [
    "Thay đổi a thì b cũng thay đổi theo\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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": [
    "Chuyển từ mảng NumPy về Tensor\n",
    "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
    "Thay đổi a thì b cũng thay đổi theo\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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": [
    "Tất cả các kiểu Tensor (trên CPU) ngoại trừ CharTensor đều hỗ trợ chuyển đổi với NumPy và ngược lại.\n",
    "\n",
    "Tensors trên CUDA\n",
    "------------\n",
    "\n",
    "(CUDA là nền tảng tính toán GPU của NVidia) \n",
    "Tensor có thể được chuyển đến thiết bị bất kỳ bằng cách gọi hàm ``.to`` .\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Chạy nếu như máy tính hỗ trợ CUDA (có GPU của NVidia)\n",
    "# Dùng ``torch.device`` để đưa tensors ra/vào 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!"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}