PyTorHướng dẫn ch

Py là gìTorh?

PyTorch là một nguồn mở TorThư viện học máy dựa trên ch dành cho xử lý ngôn ngữ tự nhiên sử dụng PythonNó tương tự như NumPy nhưng có khả năng hỗ trợ GPU mạnh mẽ hơn. Nó cung cấp các đồ thị tính toán động mà bạn có thể chỉnh sửa ngay lập tức với sự trợ giúp của autograd.Py.Torch cũng nhanh hơn một số framework khác. Nó được phát triển bởi Nhóm Nghiên cứu Trí tuệ Nhân tạo của Facebook vào năm 2016.

Biết Py là gìTorChương này đưa ra cái nhìn cân bằng về cả điểm mạnh và điểm yếu của nó.

PyTorƯu điểm và nhược điểm

Sau đây là những ưu điểm và nhược điểm của PyTorch:

Ưu điểm của PyTorch

1. Thư viện đơn giản
   PyTorMã nguồn của thư viện ch rất đơn giản. Nó dễ hiểu và bạn có thể sử dụng thư viện ngay lập tức. Ví dụ, hãy xem đoạn mã bên dưới:

class Net(torch.nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

Như đã đề cập ở trên, bạn có thể xác định mô hình mạng một cách dễ dàng và có thể hiểu mã nhanh chóng mà không cần đào tạo nhiều.

2. Đồ thị tính toán động

Nguồn ảnh: Khám phá học sâu với PyTorch

PyTorch cung cấp Đồ thị Tính toán Động (DAG). Đồ thị tính toán là một cách để biểu diễn các biểu thức toán học trong các mô hình hoặc lý thuyết đồ thị như các nút và cạnh. Nút sẽ thực hiện phép toán, và cạnh là một Tensor sẽ được đưa vào các nút và mang đầu ra của nút dưới dạng Tensor.

DAG là một biểu đồ có hình dạng tùy ý và có thể thực hiện các thao tác giữa các biểu đồ đầu vào khác nhau. Mỗi lần lặp lại, một biểu đồ mới được tạo ra. Vì vậy, có thể có cấu trúc biểu đồ giống nhau hoặc tạo một biểu đồ mới với một phép toán khác hoặc chúng ta có thể gọi nó là biểu đồ động.

3. Hiệu suất tốt hơn

Cộng đồng và các nhà nghiên cứu, đánh giá và so sánh các khung để xem khung nào nhanh hơn. Kho lưu trữ GitHub Điểm chuẩn trên các khung và GPU học sâu Py đã báo cáo rằng PyTorch nhanh hơn các framework khác về số lượng ảnh được xử lý mỗi giây.

Như bạn có thể thấy bên dưới, biểu đồ so sánh với vgg16 và resnet152

4. Native Python

PyTorch dựa nhiều hơn vào Python. Ví dụ, nếu bạn muốn huấn luyện một mô hình, bạn có thể sử dụng luồng điều khiển gốc như loo.ping và các phép đệ quy mà không cần thêm các biến hoặc phiên đặc biệt nào để có thể chạy chúng. Điều này rất hữu ích cho quá trình đào tạo.

PyTorch cũng triển khai Lập trình Mệnh lệnh, và chắc chắn là linh hoạt hơn. Vì vậy, có thể in ra giá trị tensor ngay giữa quá trình tính toán.

Nhược điểm của PyTorch

PyTorch yêu cầu các ứng dụng của bên thứ ba để trực quan hóa. Nó cũng cần một máy chủ API để vận hành trong môi trường sản xuất.

Tiếp theo trong loạt bài Py nàyTorTrong bài hướng dẫn này, chúng ta sẽ tìm hiểu về sự khác biệt giữa Py.Torch và TensorFlow.

PyTorch so với TensorFlow

Với mục đích so sánh như vậy, bước tiếp theo là cài đặt Py.Torch đang chạy cục bộ hoặc trên đám mây.

Cài đặt PyTorch

Linux

Thật đơn giản để cài đặt nó trong Linux. Bạn có thể chọn sử dụng môi trường ảo hoặc cài đặt trực tiếp với quyền truy cập root. Nhập lệnh này trong terminal

pip3 install --upgrade torch torchvision

Nhà sản xuất hiền nhân AWS

Sagemaker là một trong những nền tảng trong Amazon Dịch vụ web cung cấp công cụ Machine Learning mạnh mẽ với các cấu hình deep learning được cài đặt sẵn để nhà khoa học hoặc nhà phát triển dữ liệu xây dựng, đào tạo và triển khai các mô hình ở mọi quy mô.

Đầu tiên mở Amazon người làm hiền triết bảng điều khiển và nhấp vào Tạo phiên bản sổ ghi chép và điền đầy đủ thông tin cho sổ ghi chép của bạn.

Bước tiếp theo, nhấp vào Mở để khởi chạy phiên bản sổ ghi chép của bạn.

Cuối cùng, trong JupyterNhấp vào New và chọn conda_pytorch_p36, sau đó bạn đã sẵn sàng sử dụng phiên bản notebook của mình với Py.Torđã cài đặt ch.

Tiếp theo trong loạt bài Py nàyTorTrong bài hướng dẫn này, chúng ta sẽ học về Py.TorCác nguyên tắc cơ bản của khung ch.

Sau khi cài đặt hoàn tất, bước tiếp theo là xây dựng API.

PyTorch Kiến thức cơ bản về khung

Hãy cùng tìm hiểu những khái niệm cơ bản về Python.Torch trước khi chúng ta đi sâu vào vấn đề. PyTorch sử dụng Tensor cho mọi biến, tương tự như ndarray của numpy nhưng có hỗ trợ tính toán trên GPU. Ở đây, chúng ta sẽ giải thích về mô hình mạng, hàm mất mát, thuật toán Backprop và Optimizer.

Mô hình mạng

Mạng có thể được xây dựng bằng cách phân lớp torch.nn. Có 2 phần chính,

1. Phần đầu tiên là xác định các tham số và lớp mà bạn sẽ sử dụng
2. Phần thứ hai là nhiệm vụ chính được gọi là quá trình chuyển tiếp sẽ lấy đầu vào và dự đoán đầu ra.

Import torch
import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
 def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(3, 20, 5)
        self.conv2 = nn.Conv2d(20, 40, 5)
self.fc1 = nn.Linear(320, 10)

def forward(self, x):
       x = F.relu(self.conv1(x))
       x = F.relu(self.conv2(x))
       x = x.view(-1, 320)
       x = F.relu(self.fc1(x))
       return F.log_softmax(x)

net = Model()

Như bạn có thể thấy ở trên, bạn tạo một lớp nn.Module có tên là Model. Nó chứa 2 lớp Conv2d và một lớp Tuyến tính. Lớp đối lưu đầu tiên có đầu vào là 2 và hình dạng đầu ra là 3. Lớp thứ hai sẽ có đầu vào là 20 và sẽ tạo ra hình dạng đầu ra là 20. Lớp cuối cùng là lớp được kết nối đầy đủ có hình dạng 40 và sẽ tạo ra đầu ra là 320.

Quá trình chuyển tiếp sẽ lấy đầu vào của X và đưa nó vào lớp đối lưu1 và thực hiện chức năng ReLU,

Tương tự, nó cũng sẽ cung cấp lớp conv2. Sau đó, x sẽ được định hình lại thành (-1, 320) và đưa vào lớp FC cuối cùng. Trước khi gửi đầu ra, bạn sẽ sử dụng chức năng kích hoạt softmax.

Quá trình lùi được xác định tự động bởi autograd, do đó bạn chỉ cần xác định quy trình chuyển tiếp.

Mất chức năng

Hàm mất mát được sử dụng để đo lường mức độ chính xác của mô hình dự đoán trong việc dự đoán kết quả mong đợi. PyTorch đã có sẵn nhiều hàm mất mát tiêu chuẩn trong mô-đun torch.nn. Ví dụ, bạn có thể sử dụng hàm mất mát Cross-Entropy để giải quyết bài toán Py đa lớp.TorBài toán phân loại ch. Việc định nghĩa hàm mất mát và tính toán các giá trị mất mát rất dễ dàng:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Bạn có thể dễ dàng sử dụng phương pháp tính toán hàm mất mát riêng của mình với Py.Torch.

Chống đỡ sau

Để thực hiện lan truyền ngược, bạn chỉ cần gọi los.backward(). Lỗi sẽ được tính toán nhưng hãy nhớ xóa gradient hiện có bằng zero_grad()

net.zero_grad() # to clear the existing gradient
loss.backward() # to perform backpropragation

Trình tối ưu hóa

Torch.optim cung cấp các thuật toán tối ưu hóa phổ biến. Bạn có thể xác định trình tối ưu hóa bằng một bước đơn giản:

optimizer = torch.optim.SGD(net.parameters(), lr = 0.01, momentum=0.9)

Bạn cần truyền các tham số mô hình mạng và tốc độ học để ở mỗi lần lặp, các tham số sẽ được cập nhật sau quá trình backprop.

Cách đơn giản nhất để học API là thông qua một ví dụ nhỏ, hoàn chỉnh từ đầu đến cuối.

Hồi quy đơn giản với PyTorch

Hãy cùng học hồi quy đơn giản với Py.TorVí dụ về ch:

Bước 1) Tạo mô hình mạng của chúng tôi

Mô hình mạng của chúng tôi là một lớp Tuyến tính đơn giản với hình dạng đầu vào và đầu ra là 1.

from __future__ import print_function

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable

class Net(nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

net = Net()
print(net)

Và đầu ra mạng sẽ như thế này

Net(
  (hidden): Linear(in_features=1, out_features=1, bias=True)
)

Bước 2) Dữ liệu kiểm tra

Trước khi bắt đầu quá trình đào tạo, bạn cần biết dữ liệu của chúng tôi. Bạn thực hiện một hàm ngẫu nhiên để kiểm tra mô hình của chúng tôi. Y = x³ sin(x)+ 3x+0.8 rand(100)

# Visualize our data
import matplotlib.pyplot as plt
import numpy as np

x = np.random.rand(100)
y = np.sin(x) * np.power(x,3) + 3*x + np.random.rand(100)*0.8

plt.scatter(x, y)
plt.show()

Đây là biểu đồ phân tán của chức năng của chúng tôi:

Trước khi bắt đầu quá trình huấn luyện, bạn cần chuyển đổi mảng numpy thành các biến được hỗ trợ bởi Torch và autograd như được hiển thị trong Py bên dướiTorVí dụ về hồi quy ch.

# convert numpy array to tensor in shape of input size
x = torch.from_numpy(x.reshape(-1,1)).float()
y = torch.from_numpy(y.reshape(-1,1)).float()
print(x, y)

Bước 3) Tối ưu hóa và mất mát

Tiếp theo, bạn nên xác định Trình tối ưu hóa và Hàm mất cho quá trình đào tạo của chúng tôi.

# Define Optimizer and Loss Function
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)
loss_func = torch.nn.MSELoss()

Bước 4) Đào tạo

Bây giờ hãy bắt đầu quá trình đào tạo của chúng tôi. Với kỷ nguyên 250, bạn sẽ lặp lại dữ liệu của chúng tôi để tìm giá trị tốt nhất cho siêu tham số của chúng tôi.

inputs = Variable(x)
outputs = Variable(y)
for i in range(250):
   prediction = net(inputs)
   loss = loss_func(prediction, outputs) 
   optimizer.zero_grad()
   loss.backward()        
   optimizer.step()       

   if i % 10 == 0:
       # plot and show learning process
       plt.cla()
       plt.scatter(x.data.numpy(), y.data.numpy())
       plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=2)
       plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 10, 'color':  'red'})
       plt.pause(0.1)

plt.show()

Bước 5) Kết quả

Như bạn thấy bên dưới, bạn đã thực hiện Py thành công.TorHồi quy ch với mạng nơ-ron. Thực tế, ở mỗi lần lặp, đường màu đỏ trong đồ thị sẽ cập nhật và thay đổi vị trí để phù hợp với dữ liệu. Nhưng trong hình này, nó chỉ hiển thị kết quả cuối cùng như được hiển thị trong mã Py bên dưới.TorVí dụ:

Hồi quy chỉ là bài tập khởi động; phân loại hình ảnh giúp rèn luyện khả năng học sâu của Python.Torch.

Ví dụ về phân loại ảnh bằng PyTorch

Một trong những phương pháp phổ biến để học những kiến ​​thức cơ bản về học kĩ càng là với bộ dữ liệu MNIST. Đó là “Hello World” trong học sâu. Bộ dữ liệu chứa các số viết tay từ 0 – 9 với tổng số 60,000 mẫu huấn luyện và 10,000 mẫu thử nghiệm đã được dán nhãn kích thước 28×28 pixel.

Bước 1) Xử lý trước dữ liệu

Trong bước đầu tiên của Py nàyTorVí dụ về phân loại ch, bạn sẽ tải tập dữ liệu bằng mô-đun torchvision.

Trước khi bắt đầu quá trình huấn luyện, bạn cần hiểu rõ dữ liệu. Torchvision sẽ tải tập dữ liệu và chuyển đổi các hình ảnh theo yêu cầu phù hợp với mạng, chẳng hạn như hình dạng và chuẩn hóa hình ảnh.

import torch
import torchvision
import numpy as np
from torchvision import datasets, models, transforms

# This is used to transform the images to Tensor and normalize it
transform = transforms.Compose(
   [transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

training = torchvision.datasets.MNIST(root='./data', train=True,
                                       download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(training, batch_size=4,
                                         shuffle=True, num_workers=2)

testing = torchvision.datasets.MNIST(root='./data', train=False,
                                      download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(testing, batch_size=4,
                                        shuffle=False, num_workers=2)

classes = ('0', '1', '2', '3',
          '4', '5', '6', '7', '8', '9')
         
import matplotlib.pyplot as plt
import numpy as np

#create an iterator for train_loader
# get random training images
data_iterator = iter(train_loader)
images, labels = data_iterator.next()

#plot 4 images to visualize the data
rows = 2
columns = 2
fig=plt.figure()
for i in range(4):
   fig.add_subplot(rows, columns, i+1)
   plt.title(classes[labels[i]])
   img = images[i] / 2 + 0.5     # this is for unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

Hàm biến đổi chuyển đổi hình ảnh thành tensor và chuẩn hóa giá trị. Hàm torchvision.transforms.MNIST, sẽ tải xuống tập dữ liệu (nếu không có) trong thư mục, đặt tập dữ liệu để đào tạo nếu cần và thực hiện quá trình chuyển đổi.

Để trực quan hóa tập dữ liệu, bạn sử dụng data_iterator để lấy lô hình ảnh và nhãn tiếp theo. Bạn sử dụng matplot để vẽ những hình ảnh này và nhãn thích hợp của chúng. Như bạn có thể thấy bên dưới hình ảnh của chúng tôi và nhãn của chúng.

Bước 2) Cấu hình mô hình mạng

Bây giờ trong Py nàyTorVí dụ, bạn sẽ tạo một mạng nơ-ron đơn giản cho Python.Torphân loại hình ảnh ch.

Ở đây, chúng tôi giới thiệu cho bạn một cách khác để tạo mô hình mạng trong Python.TorChúng ta sẽ sử dụng nn.Sequential để tạo mô hình chuỗi thay vì tạo một lớp con của nn.Module.

import torch.nn as nn

# flatten the tensor into 
class Flatten(nn.Module):
   def forward(self, input):
       return input.view(input.size(0), -1)

#sequential based model
seq_model = nn.Sequential(
           nn.Conv2d(1, 10, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           nn.Dropout2d(),
           nn.Conv2d(10, 20, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           Flatten(),
           nn.Linear(320, 50),
           nn.ReLU(),
           nn.Linear(50, 10),
           nn.Softmax(),
         )

net = seq_model
print(net)

Đây là đầu ra của mô hình mạng của chúng tôi

Sequential(
  (0): Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1))
  (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (2): ReLU()
  (3): Dropout2d(p=0.5)
  (4): Conv2d(10, 20, kernel_size=(5, 5), stride=(1, 1))
  (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (6): ReLU()
  (7): Flatten()
  (8): Linear(in_features=320, out_features=50, bias=True)
  (9): ReLU()
  (10): Linear(in_features=50, out_features=10, bias=True)
  (11): Softmax()
)

Giải thích mạng

1. Trình tự là lớp đầu tiên là lớp Conv2D có hình dạng đầu vào là 1 và hình dạng đầu ra là 10 với kích thước hạt nhân là 5
2. Tiếp theo, bạn có lớp MaxPool2D
3. Chức năng kích hoạt ReLU
4. một lớp Dropout để loại bỏ các giá trị xác suất thấp.
5. Sau đó, Conv2d thứ hai với hình dạng đầu vào là 10 từ lớp cuối cùng và hình dạng đầu ra là 20 với kích thước hạt nhân là 5
6. Tiếp theo là lớp MaxPool2d
7. Chức năng kích hoạt ReLU.
8. Sau đó, bạn sẽ làm phẳng tensor trước khi đưa nó vào lớp Linear
9. Lớp tuyến tính sẽ ánh xạ đầu ra của chúng tôi ở lớp Tuyến tính thứ hai với chức năng kích hoạt softmax

Bước 3) Huấn luyện mô hình

Trước khi bắt đầu quá trình đào tạo, cần phải thiết lập chức năng tiêu chí và tối ưu hóa.

Đối với tiêu chí lựa chọn, bạn sẽ sử dụng CrossEntropyLoss. Đối với thuật toán tối ưu hóa, bạn sẽ sử dụng SGD với tốc độ học là 0.001 và hệ số quán tính là 0.9 như được hiển thị trong mã Py bên dưới.TorVí dụ.

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

Quá trình chuyển tiếp sẽ lấy hình dạng đầu vào và chuyển nó sang lớp đối lưu đầu tiên. Sau đó, nó sẽ được đưa vào maxpool2d và cuối cùng được đưa vào hàm kích hoạt ReLU. Quá trình tương tự sẽ xảy ra ở lớp đối lưu thứ hai. Sau đó, đầu vào sẽ được định hình lại thành (-2) và đưa vào lớp fc để dự đoán đầu ra.

Bây giờ, bạn sẽ bắt đầu quá trình đào tạo. Bạn sẽ lặp lại tập dữ liệu của chúng tôi 2 lần hoặc với kỷ nguyên là 2 và in ra mức lỗ hiện tại ở mỗi đợt 2000.

for epoch in range(2): 

#set the running loss at each epoch to zero
   running_loss = 0.0
# we will enumerate the train loader with starting index of 0
# for each iteration (i) and the data (tuple of input and labels)
   for i, data in enumerate(train_loader, 0):
       inputs, labels = data

# clear the gradient
       optimizer.zero_grad()

#feed the input and acquire the output from network
       outputs = net(inputs)

#calculating the predicted and the expected loss
       loss = criterion(outputs, labels)

#compute the gradient
       loss.backward()

#update the parameters
       optimizer.step()

       # print statistics
       running_loss += loss.item()
       if i % 1000 == 0:
           print('[%d, %5d] loss: %.3f' %
                 (epoch + 1, i + 1, running_loss / 1000))
           running_loss = 0.0

Ở mỗi kỷ nguyên, điều tra viên sẽ nhận được bộ dữ liệu đầu vào tiếp theo và các nhãn tương ứng. Trước khi cung cấp đầu vào cho mô hình mạng của mình, chúng tôi cần xóa gradient trước đó. Điều này là cần thiết vì sau quá trình truyền ngược (quá trình lan truyền ngược), gradient sẽ được tích lũy thay vì bị thay thế. Sau đó, chúng ta sẽ tính toán tổn thất từ ​​sản lượng dự đoán từ sản lượng dự kiến. Sau đó, chúng tôi sẽ thực hiện lan truyền ngược để tính toán độ dốc và cuối cùng, chúng tôi sẽ cập nhật các tham số.

Đây là kết quả của quá trình đào tạo

[1, 	1] loss: 0.002
[1,  1001] loss: 2.302
[1,  2001] loss: 2.295
[1,  3001] loss: 2.204
[1,  4001] loss: 1.930
[1,  5001] loss: 1.791
[1,  6001] loss: 1.756
[1,  7001] loss: 1.744
[1,  8001] loss: 1.696
[1,  9001] loss: 1.650
[1, 10001] loss: 1.640
[1, 11001] loss: 1.631
[1, 12001] loss: 1.631
[1, 13001] loss: 1.624
[1, 14001] loss: 1.616
[2, 	1] loss: 0.001
[2,  1001] loss: 1.604
[2,  2001] loss: 1.607
[2,  3001] loss: 1.602
[2,  4001] loss: 1.596
[2,  5001] loss: 1.608
[2,  6001] loss: 1.589
[2,  7001] loss: 1.610
[2,  8001] loss: 1.596
[2,  9001] loss: 1.598
[2, 10001] loss: 1.603
[2, 11001] loss: 1.596
[2, 12001] loss: 1.587
[2, 13001] loss: 1.596
[2, 14001] loss: 1.603

Bước 4) Kiểm tra mô hình

Sau khi đào tạo mô hình của chúng tôi, bạn cần kiểm tra hoặc đánh giá bằng các bộ hình ảnh khác.

Chúng tôi sẽ sử dụng một trình vòng lặp cho test_loader và nó sẽ tạo ra một loạt hình ảnh và nhãn sẽ được chuyển đến mô hình được đào tạo. Đầu ra dự đoán sẽ được hiển thị và so sánh với đầu ra dự kiến.

#make an iterator from test_loader
#Get a batch of training images
test_iterator = iter(test_loader)
images, labels = test_iterator.next()

results = net(images)
_, predicted = torch.max(results, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

fig2 = plt.figure()
for i in range(4):
   fig2.add_subplot(rows, columns, i+1)
   plt.title('truth ' + classes[labels[i]] + ': predict ' + classes[predicted[i]])
   img = images[i] / 2 + 0.5     # this is to unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

Câu Hỏi Thường Gặp