{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2822ac98",
   "metadata": {
    "origin_pos": 0
   },
   "source": [
    "# Thực hiện ngắn gọn của hồi quy tuyến tính\n",
    ":label:`sec_linear_concise`\n",
    "\n",
    "Sự quan tâm rộng rãi và mãnh liệt trong việc học sâu trong nhiều năm qua đã truyền cảm hứng cho các công ty, học giả và những người có sở thích phát triển một loạt các khuôn khổ nguồn mở trưởng thành để tự động hóa công việc lặp đi lặp lại của việc thực hiện các thuật toán học tập dựa trên độ dốc. Năm :numref:`sec_linear_scratch`, chúng tôi chỉ dựa vào (i) hàng chục để lưu trữ dữ liệu và đại số tuyến tính; và (ii) tự động phân biệt để tính toán độ dốc. Trong thực tế, bởi vì các bộ lặp dữ liệu, chức năng mất mát, tối ưu hóa và các lớp mạng thần kinh rất phổ biến, các thư viện hiện đại cũng triển khai các thành phần này cho chúng ta. \n",
    "\n",
    "Trong phần này, (**chúng tôi sẽ chỉ cho bạn cách thực hiện mô hình hồi quy tuyến tính**) từ :numref:`sec_linear_scratch` (**chính xác bằng cách sử dụng APIs cấp cao**) của các framework học sâu. \n",
    "\n",
    "## Tạo tập dữ liệu\n",
    "\n",
    "Để bắt đầu, chúng ta sẽ tạo ra cùng một tập dữ liệu như trong :numref:`sec_linear_scratch`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b06fc9a6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-04-26T12:19:18.075353Z",
     "iopub.status.busy": "2022-04-26T12:19:18.074843Z",
     "iopub.status.idle": "2022-04-26T12:19:20.639325Z",
     "shell.execute_reply": "2022-04-26T12:19:20.637188Z"
    },
    "origin_pos": 2,
    "tab": [
     "pytorch"
    ]
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "from torch.utils import data\n",
    "from d2l import torch as d2l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3f61f8b3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-04-26T12:19:20.644728Z",
     "iopub.status.busy": "2022-04-26T12:19:20.644263Z",
     "iopub.status.idle": "2022-04-26T12:19:20.651672Z",
     "shell.execute_reply": "2022-04-26T12:19:20.650581Z"
    },
    "origin_pos": 4,
    "tab": [
     "pytorch"
    ]
   },
   "outputs": [],
   "source": [
    "true_w = torch.tensor([2, -3.4])\n",
    "true_b = 4.2\n",
    "features, labels = d2l.synthetic_data(true_w, true_b, 1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "878227d4",
   "metadata": {
    "origin_pos": 5
   },
   "source": [
    "## Đọc tập dữ liệu\n",
    "\n",
    "Thay vì lăn iterator của riêng mình, chúng ta có thể [** gọi API hiện có trong một framework để đọc dữ liệu**] Chúng tôi vượt qua `features` và `labels` làm đối số và chỉ định `batch_size` khi khởi tạo một đối tượng lặp dữ liệu. Bên cạnh đó, giá trị boolean `is_train` cho biết liệu chúng ta có muốn đối tượng lặp dữ liệu xáo trộn dữ liệu trên mỗi kỷ nguyên hay không (đi qua bộ dữ liệu).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a1396022",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-04-26T12:19:20.654919Z",
     "iopub.status.busy": "2022-04-26T12:19:20.654473Z",
     "iopub.status.idle": "2022-04-26T12:19:20.659577Z",
     "shell.execute_reply": "2022-04-26T12:19:20.658654Z"
    },
    "origin_pos": 7,
    "tab": [
     "pytorch"
    ]
   },
   "outputs": [],
   "source": [
    "def load_array(data_arrays, batch_size, is_train=True):  #@save\n",
    "    \"\"\"Construct a PyTorch data iterator.\"\"\"\n",
    "    dataset = data.TensorDataset(*data_arrays)\n",
    "    return data.DataLoader(dataset, batch_size, shuffle=is_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6b57b4a2",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-04-26T12:19:20.665839Z",
     "iopub.status.busy": "2022-04-26T12:19:20.665575Z",
     "iopub.status.idle": "2022-04-26T12:19:20.669909Z",
     "shell.execute_reply": "2022-04-26T12:19:20.669085Z"
    },
    "origin_pos": 9,
    "tab": [
     "pytorch"
    ]
   },
   "outputs": [],
   "source": [
    "batch_size = 10\n",
    "data_iter = load_array((features, labels), batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a9c3e4e",
   "metadata": {
    "origin_pos": 10
   },
   "source": [
    "Bây giờ chúng ta có thể sử dụng `data_iter` theo cách tương tự như chúng ta gọi hàm `data_iter` trong :numref:`sec_linear_scratch`. Để xác minh rằng nó đang hoạt động, chúng ta có thể đọc và in minibatch đầu tiên của các ví dụ. So sánh với :numref:`sec_linear_scratch`, ở đây chúng ta sử dụng `iter` để xây dựng một iterator Python và sử dụng `next` để lấy mục đầu tiên từ iterator.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d7af9caf",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-04-26T12:19:20.674534Z",
     "iopub.status.busy": "2022-04-26T12:19:20.673670Z",
     "iopub.status.idle": "2022-04-26T12:19:20.687317Z",
     "shell.execute_reply": "2022-04-26T12:19:20.686536Z"
    },
    "origin_pos": 11,
    "tab": [
     "pytorch"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[tensor([[-1.0768, -1.1891],\n",
       "         [-0.8970, -0.1291],\n",
       "         [ 0.5670, -0.2283],\n",
       "         [-1.2042, -0.2695],\n",
       "         [-0.8318,  0.5172],\n",
       "         [-0.5357,  1.0894],\n",
       "         [-0.3336,  0.1212],\n",
       "         [ 0.9926, -0.1793],\n",
       "         [ 0.2501,  0.5808],\n",
       "         [ 1.4849,  0.8004]]),\n",
       " tensor([[ 6.0941],\n",
       "         [ 2.8334],\n",
       "         [ 6.1015],\n",
       "         [ 2.7120],\n",
       "         [ 0.7793],\n",
       "         [-0.5745],\n",
       "         [ 3.1419],\n",
       "         [ 6.7983],\n",
       "         [ 2.7231],\n",
       "         [ 4.4351]])]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(iter(data_iter))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c24abe2",
   "metadata": {
    "origin_pos": 12
   },
   "source": [
    "## Xác định mô hình\n",
    "\n",
    "Khi chúng tôi thực hiện hồi quy tuyến tính từ đầu vào năm :numref:`sec_linear_scratch`, chúng tôi đã xác định các tham số mô hình của mình một cách rõ ràng và mã hóa các phép tính để tạo ra đầu ra bằng cách sử dụng các phép toán đại số tuyến tính cơ bản. Bạn * nên biết làm thế nào để làm điều này. Nhưng một khi mô hình của bạn trở nên phức tạp hơn, và một khi bạn phải làm điều này gần như mỗi ngày, bạn sẽ rất vui vì được hỗ trợ. Tình hình tương tự như mã hóa blog của riêng bạn từ đầu. Làm điều đó một hoặc hai lần là bổ ích và hướng dẫn, nhưng bạn sẽ là một nhà phát triển web tệ hại nếu mỗi khi bạn cần một blog bạn đã dành một tháng để phát minh lại bánh xe. \n",
    "\n",
    "Đối với các phép toán chuẩn, chúng ta có thể [** sử dụng các lớp được xác định trước của framework, **] cho phép chúng ta tập trung đặc biệt vào các layer dùng để xây dựng mô hình chứ không phải tập trung vào việc triển khai. Trước tiên chúng ta sẽ xác định một biến mô hình `net`, sẽ đề cập đến một phiên bản của lớp `Sequential`. Lớp `Sequential` định nghĩa một container cho nhiều lớp sẽ được xích lại với nhau. Cho dữ liệu đầu vào, một trường hợp `Sequential` truyền nó qua lớp đầu tiên, lần lượt đi qua đầu ra dưới dạng đầu vào của lớp thứ hai và vân vân. Trong ví dụ sau, mô hình của chúng tôi chỉ bao gồm một lớp, vì vậy chúng tôi không thực sự cần `Sequential`. Nhưng vì gần như tất cả các mô hình trong tương lai của chúng tôi sẽ liên quan đến nhiều lớp, dù sao chúng tôi sẽ sử dụng nó chỉ để làm quen với bạn với quy trình làm việc tiêu chuẩn nhất. \n",
    "\n",
    "Nhớ lại kiến trúc của một mạng một lớp như thể hiện trong :numref:`fig_single_neuron`. Lớp được cho là * kết nối đầy đủ* bởi vì mỗi đầu vào của nó được kết nối với mỗi đầu ra của nó bằng phương pháp nhân ma thuật-vector.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d65396dd",
   "metadata": {
    "origin_pos": 14,
    "tab": [
     "pytorch"
    ]
   },
   "source": [
    "Trong PyTorch, lớp kết nối hoàn toàn được định nghĩa trong lớp `Linear`. Lưu ý rằng chúng tôi đã thông qua hai đối số vào `nn.Linear`. Cái đầu tiên xác định kích thước đối tượng đầu vào, đó là 2, và thứ hai là kích thước tính năng đầu ra, đó là một vô hướng duy nhất và do đó 1.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5a1d4462",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-04-26T12:19:20.694991Z",
     "iopub.status.busy": "2022-04-26T12:19:20.694456Z",
     "iopub.status.idle": "2022-04-26T12:19:20.698922Z",
     "shell.execute_reply": "2022-04-26T12:19:20.698118Z"
    },
    "origin_pos": 17,
    "tab": [
     "pytorch"
    ]
   },
   "outputs": [],
   "source": [
    "# `nn` is an abbreviation for neural networks\n",
    "from torch import nn\n",
    "\n",
    "net = nn.Sequential(nn.Linear(2, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c250ecbb",
   "metadata": {
    "origin_pos": 19
   },
   "source": [
    "## Khởi tạo các tham số mô hình\n",
    "\n",
    "Trước khi sử dụng `net`, chúng ta cần (**khởi tạo các tham số model**) chẳng hạn như trọng lượng và thiên vị trong mô hình hồi quy tuyến tính. Các khuôn khổ học sâu thường có cách xác định trước để khởi tạo các tham số. Ở đây chúng tôi chỉ định rằng mỗi tham số trọng lượng nên được lấy mẫu ngẫu nhiên từ phân phối bình thường với 0 trung bình và độ lệch chuẩn 0,01. Tham số thiên vị sẽ được khởi tạo thành 0.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6183e182",
   "metadata": {
    "origin_pos": 21,
    "tab": [
     "pytorch"
    ]
   },
   "source": [
    "Như chúng ta đã chỉ định kích thước đầu vào và đầu ra khi xây dựng `nn.Linear`, bây giờ chúng ta có thể truy cập trực tiếp các tham số để chỉ định các giá trị ban đầu của chúng. Đầu tiên chúng tôi xác định vị trí lớp `net[0]`, là lớp đầu tiên trong mạng, sau đó sử dụng các phương thức `weight.data` và `bias.data` để truy cập các tham số. Tiếp theo chúng ta sử dụng các phương pháp thay thế `normal_` và `fill_` để ghi đè lên các giá trị tham số.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5ef1babd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-04-26T12:19:20.703274Z",
     "iopub.status.busy": "2022-04-26T12:19:20.702724Z",
     "iopub.status.idle": "2022-04-26T12:19:20.708543Z",
     "shell.execute_reply": "2022-04-26T12:19:20.707874Z"
    },
    "origin_pos": 24,
    "tab": [
     "pytorch"
    ]
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net[0].weight.data.normal_(0, 0.01)\n",
    "net[0].bias.data.fill_(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7bb0e7e",
   "metadata": {
    "origin_pos": 27,
    "tab": [
     "pytorch"
    ]
   },
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e1a4e5e",
   "metadata": {
    "origin_pos": 29
   },
   "source": [
    "## Xác định chức năng mất\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3c86c92",
   "metadata": {
    "origin_pos": 31,
    "tab": [
     "pytorch"
    ]
   },
   "source": [
    "[**Lớp `MSELoss` tính toán lỗi bình phương trung bình (không có hệ số $1/2$ trong :eqref:`eq_mse`) .**] Theo mặc định, nó trả về mức lỗ trung bình so với các ví dụ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0b06f622",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-04-26T12:19:20.712126Z",
     "iopub.status.busy": "2022-04-26T12:19:20.711768Z",
     "iopub.status.idle": "2022-04-26T12:19:20.715405Z",
     "shell.execute_reply": "2022-04-26T12:19:20.714648Z"
    },
    "origin_pos": 34,
    "tab": [
     "pytorch"
    ]
   },
   "outputs": [],
   "source": [
    "loss = nn.MSELoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95eab91b",
   "metadata": {
    "origin_pos": 36
   },
   "source": [
    "## Xác định thuật toán tối ưu hóa\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4054fba",
   "metadata": {
    "origin_pos": 38,
    "tab": [
     "pytorch"
    ]
   },
   "source": [
    "Minibatch stochastic gradient descent là một công cụ tiêu chuẩn để tối ưu hóa các mạng thần kinh và do đó PyTorch hỗ trợ nó cùng với một số biến thể trên thuật toán này trong mô-đun `optim`. Khi chúng ta (**khởi tạo một phiên bản `SGD`**) chúng ta sẽ chỉ định các tham số để tối ưu hóa (có thể đạt được từ mạng của chúng tôi thông qua `net.parameters()`), với một từ điển các siêu tham số theo yêu cầu của thuật toán tối ưu hóa của chúng tôi. Minibatch stochastic gradient gốc chỉ yêu cầu chúng ta đặt giá trị `lr`, được đặt thành 0,03 ở đây.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "4a570d4d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-04-26T12:19:20.718322Z",
     "iopub.status.busy": "2022-04-26T12:19:20.717978Z",
     "iopub.status.idle": "2022-04-26T12:19:20.721821Z",
     "shell.execute_reply": "2022-04-26T12:19:20.721171Z"
    },
    "origin_pos": 41,
    "tab": [
     "pytorch"
    ]
   },
   "outputs": [],
   "source": [
    "trainer = torch.optim.SGD(net.parameters(), lr=0.03)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec61e60e",
   "metadata": {
    "origin_pos": 43
   },
   "source": [
    "## Đào tạo\n",
    "\n",
    "Bạn có thể nhận thấy rằng thể hiện mô hình của chúng tôi thông qua các API cấp cao của một khuôn khổ học sâu đòi hỏi tương đối ít dòng mã. Chúng tôi không phải phân bổ các thông số riêng lẻ, xác định chức năng mất mát của chúng tôi hoặc thực hiện minibatch stochastic gradient descent. Khi chúng tôi bắt đầu làm việc với các mô hình phức tạp hơn nhiều, lợi thế của API cấp cao sẽ tăng lên đáng kể. Tuy nhiên, một khi chúng tôi có tất cả các phần cơ bản tại chỗ, [** bản thân vòng đào tạo rất giống với những gì chúng tôi đã làm khi thực hiện mọi thứ từ vết xước.**] \n",
    "\n",
    "Để làm mới bộ nhớ của bạn: đối với một số kỷ nguyên, chúng tôi sẽ thực hiện một vượt qua toàn bộ dữ liệu (`train_data`), lặp đi lặp lại lấy một minibatch đầu vào và các nhãn chân lý mặt đất tương ứng. Đối với mỗi minibatch, chúng tôi trải qua các nghi thức sau: \n",
    "\n",
    "* Tạo ra dự đoán bằng cách gọi `net(X)` và tính toán tổn thất `l` (sự lan truyền về phía trước).\n",
    "* Tính toán gradient bằng cách chạy backpropagation.\n",
    "* Cập nhật các tham số mô hình bằng cách gọi trình tối ưu hóa của chúng tôi.\n",
    "\n",
    "Để có biện pháp tốt, chúng tôi tính toán tổn thất sau mỗi kỷ nguyên và in nó để theo dõi tiến độ.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f2d9bb26",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-04-26T12:19:20.724745Z",
     "iopub.status.busy": "2022-04-26T12:19:20.724401Z",
     "iopub.status.idle": "2022-04-26T12:19:20.909755Z",
     "shell.execute_reply": "2022-04-26T12:19:20.908849Z"
    },
    "origin_pos": 45,
    "tab": [
     "pytorch"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch 1, loss 0.000260\n",
      "epoch 2, loss 0.000097\n",
      "epoch 3, loss 0.000096\n"
     ]
    }
   ],
   "source": [
    "num_epochs = 3\n",
    "for epoch in range(num_epochs):\n",
    "    for X, y in data_iter:\n",
    "        l = loss(net(X) ,y)\n",
    "        trainer.zero_grad()\n",
    "        l.backward()\n",
    "        trainer.step()\n",
    "    l = loss(net(features), labels)\n",
    "    print(f'epoch {epoch + 1}, loss {l:f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "848c1b52",
   "metadata": {
    "origin_pos": 47
   },
   "source": [
    "Dưới đây, chúng ta [**so sánh các tham số mô hình học được bằng cách đào tạo về dữ liệu hữu hạn và các tham số thực tế**] đã tạo ra tập dữ liệu của chúng tôi. Để truy cập các tham số, trước tiên chúng ta truy cập vào lớp mà chúng ta cần từ `net` và sau đó truy cập vào trọng lượng và thiên vị của lớp đó. Như trong triển khai từ đầu của chúng tôi, lưu ý rằng các thông số ước tính của chúng tôi gần với các đối tác thực tế mặt đất của chúng.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b4ab78fd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-04-26T12:19:20.914683Z",
     "iopub.status.busy": "2022-04-26T12:19:20.913876Z",
     "iopub.status.idle": "2022-04-26T12:19:20.922282Z",
     "shell.execute_reply": "2022-04-26T12:19:20.921606Z"
    },
    "origin_pos": 49,
    "tab": [
     "pytorch"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error in estimating w: tensor([0.0007, 0.0007])\n",
      "error in estimating b: tensor([0.0002])\n"
     ]
    }
   ],
   "source": [
    "w = net[0].weight.data\n",
    "print('error in estimating w:', true_w - w.reshape(true_w.shape))\n",
    "b = net[0].bias.data\n",
    "print('error in estimating b:', true_b - b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce814761",
   "metadata": {
    "origin_pos": 51
   },
   "source": [
    "## Tóm tắt\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f817f59",
   "metadata": {
    "origin_pos": 53,
    "tab": [
     "pytorch"
    ]
   },
   "source": [
    "* Sử dụng API cấp cao của PyTorch, chúng ta có thể triển khai các mô hình chính xác hơn nhiều.\n",
    "* Trong PyTorch, mô-đun `data` cung cấp các công cụ để xử lý dữ liệu, mô-đun `nn` định nghĩa một số lượng lớn các lớp mạng thần kinh và các chức năng mất phổ biến.\n",
    "* Chúng ta có thể khởi tạo các tham số bằng cách thay thế các giá trị của chúng bằng các phương thức kết thúc bằng `_`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d276e70",
   "metadata": {
    "origin_pos": 55
   },
   "source": [
    "## Bài tập\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90b1a0dc",
   "metadata": {
    "origin_pos": 57,
    "tab": [
     "pytorch"
    ]
   },
   "source": [
    "1. Nếu chúng ta thay thế `nn.MSELoss(reduction='sum')` bằng `nn.MSELoss()`, làm thế nào chúng ta có thể thay đổi tốc độ học tập để mã hoạt động giống hệt nhau. Tại sao?\n",
    "1. Xem lại tài liệu PyTorch để xem các chức năng mất mát và phương pháp khởi tạo được cung cấp. Thay thế tổn thất bằng mất mát của Huber.\n",
    "1. Làm thế nào để bạn truy cập gradient của `net[0].weight`?\n",
    "\n",
    "[Discussions](https://discuss.d2l.ai/t/45)\n"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}