{ "cells": [ { "cell_type": "markdown", "id": "f5e0da4f", "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": "6ff052ee", "metadata": { "execution": { "iopub.execute_input": "2022-04-26T10:49:10.477878Z", "iopub.status.busy": "2022-04-26T10:49:10.477419Z", "iopub.status.idle": "2022-04-26T10:49:12.924672Z", "shell.execute_reply": "2022-04-26T10:49:12.923929Z" }, "origin_pos": 1, "tab": [ "mxnet" ] }, "outputs": [], "source": [ "from mxnet import autograd, gluon, np, npx\n", "from d2l import mxnet as d2l\n", "\n", "npx.set_np()" ] }, { "cell_type": "code", "execution_count": 2, "id": "1c606cf7", "metadata": { "execution": { "iopub.execute_input": "2022-04-26T10:49:12.929059Z", "iopub.status.busy": "2022-04-26T10:49:12.928658Z", "iopub.status.idle": "2022-04-26T10:49:12.935686Z", "shell.execute_reply": "2022-04-26T10:49:12.934777Z" }, "origin_pos": 4, "tab": [ "mxnet" ] }, "outputs": [], "source": [ "true_w = np.array([2, -3.4])\n", "true_b = 4.2\n", "features, labels = d2l.synthetic_data(true_w, true_b, 1000)" ] }, { "cell_type": "markdown", "id": "e76444db", "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": "a8f801d3", "metadata": { "execution": { "iopub.execute_input": "2022-04-26T10:49:12.938634Z", "iopub.status.busy": "2022-04-26T10:49:12.938247Z", "iopub.status.idle": "2022-04-26T10:49:12.943365Z", "shell.execute_reply": "2022-04-26T10:49:12.942723Z" }, "origin_pos": 6, "tab": [ "mxnet" ] }, "outputs": [], "source": [ "def load_array(data_arrays, batch_size, is_train=True): #@save\n", " \"\"\"Construct a Gluon data iterator.\"\"\"\n", " dataset = gluon.data.ArrayDataset(*data_arrays)\n", " return gluon.data.DataLoader(dataset, batch_size, shuffle=is_train)" ] }, { "cell_type": "code", "execution_count": 4, "id": "c7dc65f4", "metadata": { "execution": { "iopub.execute_input": "2022-04-26T10:49:12.946246Z", "iopub.status.busy": "2022-04-26T10:49:12.945914Z", "iopub.status.idle": "2022-04-26T10:49:12.949525Z", "shell.execute_reply": "2022-04-26T10:49:12.948840Z" }, "origin_pos": 9, "tab": [ "mxnet" ] }, "outputs": [], "source": [ "batch_size = 10\n", "data_iter = load_array((features, labels), batch_size)" ] }, { "cell_type": "markdown", "id": "879c2fd1", "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": "0bf188c9", "metadata": { "execution": { "iopub.execute_input": "2022-04-26T10:49:12.952615Z", "iopub.status.busy": "2022-04-26T10:49:12.952201Z", "iopub.status.idle": "2022-04-26T10:49:12.961974Z", "shell.execute_reply": "2022-04-26T10:49:12.961360Z" }, "origin_pos": 11, "tab": [ "mxnet" ] }, "outputs": [ { "data": { "text/plain": [ "[array([[-1.3689033 , -0.20985045],\n", " [ 0.03926884, -1.3402625 ],\n", " [ 1.0731696 , 1.8307649 ],\n", " [ 0.97980016, -1.0509403 ],\n", " [ 0.68469703, 1.7043087 ],\n", " [-1.4760977 , -0.18857454],\n", " [-0.35942194, -0.9055353 ],\n", " [ 0.8289028 , -0.25843123],\n", " [ 0.30664065, -1.2474236 ],\n", " [-0.9140275 , -0.09713268]]),\n", " array([[ 2.1893177 ],\n", " [ 8.834586 ],\n", " [ 0.10456034],\n", " [ 9.746235 ],\n", " [-0.22193365],\n", " [ 1.8882912 ],\n", " [ 6.5558853 ],\n", " [ 6.7403984 ],\n", " [ 9.060337 ],\n", " [ 2.7011688 ]])]" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "next(iter(data_iter))" ] }, { "cell_type": "markdown", "id": "7191cf3e", "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": "f6378f61", "metadata": { "origin_pos": 13, "tab": [ "mxnet" ] }, "source": [ "Trong Gluon, lớp kết nối hoàn toàn được định nghĩa trong lớp `Dense`. Vì chúng ta chỉ muốn tạo ra một đầu ra vô hướng duy nhất, chúng ta đặt số đó thành 1. \n", "\n", "Điều đáng chú ý là, để thuận tiện, Gluon không yêu cầu chúng ta chỉ định hình dạng đầu vào cho mỗi lớp. Vì vậy, ở đây, chúng ta không cần phải nói với Gluon có bao nhiêu đầu vào đi vào lớp tuyến tính này. Khi lần đầu tiên chúng ta cố gắng truyền dữ liệu thông qua mô hình của mình, ví dụ, khi chúng ta thực thi `net(X)` sau đó, Gluon sẽ tự động suy ra số lượng đầu vào cho mỗi lớp. Chúng tôi sẽ mô tả cách thức hoạt động chi tiết hơn sau.\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "643f010f", "metadata": { "execution": { "iopub.execute_input": "2022-04-26T10:49:12.965319Z", "iopub.status.busy": "2022-04-26T10:49:12.964797Z", "iopub.status.idle": "2022-04-26T10:49:12.968728Z", "shell.execute_reply": "2022-04-26T10:49:12.968065Z" }, "origin_pos": 16, "tab": [ "mxnet" ] }, "outputs": [], "source": [ "# `nn` is an abbreviation for neural networks\n", "from mxnet.gluon import nn\n", "\n", "net = nn.Sequential()\n", "net.add(nn.Dense(1))" ] }, { "cell_type": "markdown", "id": "6ada385f", "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": "59476390", "metadata": { "origin_pos": 20, "tab": [ "mxnet" ] }, "source": [ "Chúng tôi sẽ nhập mô-đun `initializer` từ MXNet. mô-đun này cung cấp các phương pháp khác nhau để khởi tạo tham số mô hình. Gluon làm cho `init` có sẵn dưới dạng phím tắt (viết tắt) để truy cập gói `initializer`. Chúng tôi chỉ chỉ định cách khởi tạo trọng lượng bằng cách gọi `init.Normal(sigma=0.01)`. Các tham số thiên vị được khởi tạo thành 0 theo mặc định.\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "0b22aa45", "metadata": { "execution": { "iopub.execute_input": "2022-04-26T10:49:12.972043Z", "iopub.status.busy": "2022-04-26T10:49:12.971447Z", "iopub.status.idle": "2022-04-26T10:49:12.977187Z", "shell.execute_reply": "2022-04-26T10:49:12.976502Z" }, "origin_pos": 23, "tab": [ "mxnet" ] }, "outputs": [], "source": [ "from mxnet import init\n", "\n", "net.initialize(init.Normal(sigma=0.01))" ] }, { "cell_type": "markdown", "id": "5b11b2bd", "metadata": { "origin_pos": 26, "tab": [ "mxnet" ] }, "source": [ "Mã ở trên có thể trông đơn giản nhưng bạn nên lưu ý rằng một cái gì đó kỳ lạ đang xảy ra ở đây. Chúng tôi đang khởi tạo các tham số cho một mạng mặc dù Gluon chưa biết đầu vào sẽ có bao nhiêu kích thước! Nó có thể là 2 như trong ví dụ của chúng tôi hoặc nó có thể là 2000. Gluon cho phép chúng tôi thoát khỏi điều này bởi vì đằng sau hiện trường, việc khởi tạo thực sự là * hoãn lại*. Việc khởi tạo thực sự sẽ chỉ diễn ra khi chúng tôi lần đầu tiên cố gắng truyền dữ liệu qua mạng. Chỉ cần cẩn thận để nhớ rằng vì các tham số chưa được khởi tạo, chúng tôi không thể truy cập hoặc thao tác chúng.\n" ] }, { "cell_type": "markdown", "id": "dc81c775", "metadata": { "origin_pos": 29 }, "source": [ "## Xác định chức năng mất\n" ] }, { "cell_type": "markdown", "id": "8d4eee3a", "metadata": { "origin_pos": 30, "tab": [ "mxnet" ] }, "source": [ "Trong Gluon, mô-đun `loss` xác định các chức năng mất mát khác nhau. Trong ví dụ này, chúng ta sẽ sử dụng việc thực hiện Gluon về tổn thất bình phương (`L2Loss`).\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "9f54f0b7", "metadata": { "execution": { "iopub.execute_input": "2022-04-26T10:49:12.980416Z", "iopub.status.busy": "2022-04-26T10:49:12.979826Z", "iopub.status.idle": "2022-04-26T10:49:12.983296Z", "shell.execute_reply": "2022-04-26T10:49:12.982661Z" }, "origin_pos": 33, "tab": [ "mxnet" ] }, "outputs": [], "source": [ "loss = gluon.loss.L2Loss()" ] }, { "cell_type": "markdown", "id": "b201978f", "metadata": { "origin_pos": 36 }, "source": [ "## Xác định thuật toán tối ưu hóa\n" ] }, { "cell_type": "markdown", "id": "7f1bd9ec", "metadata": { "origin_pos": 37, "tab": [ "mxnet" ] }, "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 đó Gluon hỗ trợ nó cùng với một số biến thể trên thuật toán này thông qua lớp `Trainer` của nó. Khi chúng tôi khởi tạo `Trainer`, chúng tôi sẽ chỉ định các tham số để tối ưu hóa (có thể đạt được từ mô hình `net` của chúng tôi thông qua `net.collect_params()`), thuật toán tối ưu hóa chúng tôi muốn sử dụng (`sgd`) và 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ị `learning_rate`, được đặt thành 0,03 ở đây.\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "436d283e", "metadata": { "execution": { "iopub.execute_input": "2022-04-26T10:49:12.986345Z", "iopub.status.busy": "2022-04-26T10:49:12.985846Z", "iopub.status.idle": "2022-04-26T10:49:12.989543Z", "shell.execute_reply": "2022-04-26T10:49:12.988892Z" }, "origin_pos": 40, "tab": [ "mxnet" ] }, "outputs": [], "source": [ "from mxnet import gluon\n", "\n", "trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': 0.03})" ] }, { "cell_type": "markdown", "id": "9e4cc5c5", "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": "461db1b7", "metadata": { "execution": { "iopub.execute_input": "2022-04-26T10:49:12.993019Z", "iopub.status.busy": "2022-04-26T10:49:12.992326Z", "iopub.status.idle": "2022-04-26T10:49:13.646954Z", "shell.execute_reply": "2022-04-26T10:49:13.646176Z" }, "origin_pos": 44, "tab": [ "mxnet" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[10:49:12] src/base.cc:49: GPU context requested, but no GPUs found.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "epoch 1, loss 0.025031\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "epoch 2, loss 0.000087\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "epoch 3, loss 0.000051\n" ] } ], "source": [ "num_epochs = 3\n", "for epoch in range(num_epochs):\n", " for X, y in data_iter:\n", " with autograd.record():\n", " l = loss(net(X), y)\n", " l.backward()\n", " trainer.step(batch_size)\n", " l = loss(net(features), labels)\n", " print(f'epoch {epoch + 1}, loss {l.mean().asnumpy():f}')" ] }, { "cell_type": "markdown", "id": "167b81cf", "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": "eb4be2bf", "metadata": { "execution": { "iopub.execute_input": "2022-04-26T10:49:13.650197Z", "iopub.status.busy": "2022-04-26T10:49:13.649767Z", "iopub.status.idle": "2022-04-26T10:49:13.656029Z", "shell.execute_reply": "2022-04-26T10:49:13.655319Z" }, "origin_pos": 48, "tab": [ "mxnet" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "error in estimating w: [2.8729439e-04 3.2901764e-05]\n", "error in estimating b: [0.00047541]\n" ] } ], "source": [ "w = net[0].weight.data()\n", "print(f'error in estimating w: {true_w - w.reshape(true_w.shape)}')\n", "b = net[0].bias.data()\n", "print(f'error in estimating b: {true_b - b}')" ] }, { "cell_type": "markdown", "id": "db62e139", "metadata": { "origin_pos": 51 }, "source": [ "## Tóm tắt\n" ] }, { "cell_type": "markdown", "id": "d72eacd3", "metadata": { "origin_pos": 52, "tab": [ "mxnet" ] }, "source": [ "* Sử dụng Gluon, chúng ta có thể thực hiện các mô hình chính xác hơn nhiều.\n", "* Trong Gluon, 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à mô-đun `loss` định nghĩa nhiều chức năng mất mát phổ biến.\n", "* mô-đun của MXNet `initializer` cung cấp các phương pháp khác nhau để khởi tạo tham số mô hình.\n", "* Kích thước và lưu trữ được tự động suy ra, nhưng hãy cẩn thận không cố gắng truy cập các tham số trước khi chúng được khởi tạo.\n" ] }, { "cell_type": "markdown", "id": "018b30eb", "metadata": { "origin_pos": 55 }, "source": [ "## Bài tập\n" ] }, { "cell_type": "markdown", "id": "e6e3c7fc", "metadata": { "origin_pos": 56, "tab": [ "mxnet" ] }, "source": [ "1. Nếu chúng ta thay thế `l = loss(output, y)` bằng `l = loss(output, y).mean()`, chúng ta cần thay đổi `trainer.step(batch_size)` thành `trainer.step(1)` để mã hoạt động giống hệt nhau. Tại sao?\n", "1. Xem lại tài liệu MXNet để xem những chức năng mất mát và phương pháp khởi tạo được cung cấp trong các mô-đun `gluon.loss` và `init`. 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 `dense.weight`?\n", "\n", "[Discussions](https://discuss.d2l.ai/t/44)\n" ] } ], "metadata": { "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 5 }