บทช่วยสอน PyTorch: การถดถอย ตัวอย่างการจำแนกรูปภาพ

โดย: เอเวลิน คลาร์ก เอเวลิน คลาร์ก
Hours วันที่อัพเดท

สรุปการสอน Pytorch

ในบทช่วยสอน Pytorch นี้ คุณจะได้เรียนรู้แนวคิดทั้งหมดตั้งแต่เริ่มต้น บทช่วยสอนนี้ครอบคลุมหัวข้อพื้นฐานไปจนถึงขั้นสูง เช่น คำจำกัดความของ Pytorch ข้อดีและข้อเสียของ Pytorch การเปรียบเทียบ การติดตั้ง เฟรมเวิร์กของ Pytorch การถดถอย และการจำแนกภาพ บทช่วยสอน Pytorch นี้ไม่มีค่าใช้จ่ายใดๆ

PyTorch คืออะไร?

ไพทอร์ช เป็นไลบรารี Machine Learning ที่ใช้ Torch แบบโอเพ่นซอร์สสำหรับการประมวลผลภาษาธรรมชาติโดยใช้ Python- มันคล้ายกับ NumPy แต่รองรับ GPU ที่ทรงพลัง มีกราฟการคำนวณแบบไดนามิกที่คุณสามารถแก้ไขได้ขณะเดินทางด้วยความช่วยเหลือของระบบออโต้กราด PyTorch ยังเร็วกว่าเฟรมเวิร์กอื่นๆ อีกด้วย ได้รับการพัฒนาโดยกลุ่มวิจัย AI ของ Facebook ในปี 2016

ข้อดีและข้อเสียของ PyTorch

ต่อไปนี้เป็นข้อดีและข้อเสียของ PyTorch:

ข้อดีของ PyTorch

  1. ห้องสมุดอย่างง่าย
    รหัส PyTorch นั้นเรียบง่าย เข้าใจง่ายและคุณใช้ห้องสมุดได้ทันที ตัวอย่างเช่น ลองดูข้อมูลโค้ดด้านล่าง:
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

ตามที่กล่าวไว้ข้างต้น คุณสามารถกำหนดโมเดลเครือข่ายได้อย่างง่ายดาย และคุณสามารถเข้าใจโค้ดได้อย่างรวดเร็วโดยไม่ต้องฝึกฝนมากนัก

  1. กราฟการคำนวณแบบไดนามิก

กราฟการคำนวณแบบไดนามิก

แหล่งที่มาของภาพ: การสำรวจการเรียนรู้เชิงลึกด้วย PyTorch

Pytorch นำเสนอ Dynamic Computational Graph (DAG) กราฟเชิงคำนวณเป็นวิธีการแสดงนิพจน์ทางคณิตศาสตร์ในแบบจำลองกราฟหรือทฤษฎีต่างๆ เช่น โหนดและขอบ โหนดจะทำการดำเนินการทางคณิตศาสตร์ และขอบจะเป็นเทนเซอร์ที่ป้อนเข้าสู่โหนดและส่งเอาต์พุตของโหนดในเทนเซอร์

DAG คือกราฟที่มีรูปร่างตามต้องการและสามารถดำเนินการระหว่างกราฟอินพุตที่แตกต่างกันได้ ในแต่ละรอบ กราฟใหม่จะถูกสร้างขึ้น ดังนั้น จึงเป็นไปได้ที่จะมีโครงสร้างกราฟเดียวกัน หรือสร้างกราฟใหม่ด้วยการดำเนินการที่แตกต่างกัน หรือเราอาจเรียกกราฟนี้ว่ากราฟไดนามิกก็ได้

  1. ประสิทธิภาพที่ดีขึ้น

ชุมชนและนักวิจัย เปรียบเทียบและเปรียบเทียบกรอบงานเพื่อดูว่าอันไหนเร็วกว่า ที่เก็บ GitHub เกณฑ์มาตรฐานเกี่ยวกับกรอบการเรียนรู้เชิงลึกและ GPU รายงานว่า PyTorch เร็วกว่าเฟรมเวิร์กอื่นในแง่ของภาพที่ประมวลผลต่อวินาที

ดังที่คุณเห็นด้านล่างกราฟเปรียบเทียบกับ vgg16 และ resnet152

ข้อดีของ PyTorch

ข้อดีของ PyTorch

  1. พื้นเมือง Python

PyTorch นั้นมีพื้นฐานมาจากหลามมากกว่า ตัวอย่างเช่น หากคุณต้องการฝึกโมเดล คุณสามารถใช้โฟลว์การควบคุมดั้งเดิม เช่น การวนซ้ำและการเรียกซ้ำโดยไม่จำเป็นต้องเพิ่มตัวแปรหรือเซสชันพิเศษเพื่อให้สามารถรันได้ สิ่งนี้มีประโยชน์มากสำหรับกระบวนการฝึกอบรม

Pytorch ยังใช้ Imperative Programming และมีความยืดหยุ่นมากกว่าอย่างแน่นอน ดังนั้นจึงเป็นไปได้ที่จะพิมพ์ค่าเทนเซอร์ในระหว่างกระบวนการคำนวณได้

ข้อเสียของ PyTorch

PyTorch ต้องการแอปพลิเคชันบุคคลที่สามสำหรับการแสดงภาพ นอกจากนี้ยังต้องมีเซิร์ฟเวอร์ API สำหรับการผลิตด้วย

ต่อไปในบทช่วยสอน PyTorch นี้ เราจะเรียนรู้เกี่ยวกับความแตกต่างระหว่าง PyTorch และ TensorFlow

บทความที่เกี่ยวข้อง

PyTorch กับ เทนเซอร์โฟลว์

พารามิเตอร์ ไพทอร์ช เทนเซอร์โฟลว์
นิยามโมเดล โมเดลถูกกำหนดไว้ในคลาสย่อยและมีแพ็คเกจที่ใช้งานง่าย โมเดลถูกกำหนดไว้หลายตัว และคุณจำเป็นต้องเข้าใจไวยากรณ์
การสนับสนุน GPU ใช่ ใช่
ประเภทกราฟ พลวัต คงที่
เครื่องมือ ไม่มีเครื่องมือสร้างภาพ คุณสามารถใช้เครื่องมือแสดงภาพ Tensorboard ได้
สังคม ชุมชนยังคงเติบโต ชุมชนขนาดใหญ่ที่มีการเคลื่อนไหว

การติดตั้ง PyTorch

ลินุกซ์

การติดตั้งบน Linux นั้นตรงไปตรงมา คุณสามารถเลือกใช้สภาพแวดล้อมเสมือนหรือติดตั้งโดยตรงด้วยการเข้าถึงรูท พิมพ์คำสั่งนี้ในเทอร์มินัล

pip3 install --upgrade torch torchvision

AWS Sagemaker

Sagemaker เป็นหนึ่งในแพลตฟอร์มใน Amazon บริการเว็บ ที่มีกลไกการเรียนรู้ของเครื่องอันทรงพลังพร้อมการกำหนดค่าการเรียนรู้เชิงลึกที่ติดตั้งไว้ล่วงหน้าสำหรับนักวิทยาศาสตร์ข้อมูลหรือนักพัฒนาเพื่อสร้าง ฝึกฝน และปรับใช้โมเดลในทุกขนาด

ขั้นแรกเปิดไฟล์ Amazon ปราชญ์ คอนโซลและคลิกสร้างอินสแตนซ์สมุดบันทึกและกรอกรายละเอียดทั้งหมดสำหรับสมุดบันทึกของคุณ

AWS Sagemaker

ขั้นตอนถัดไป คลิกเปิดเพื่อเปิดอินสแตนซ์โน้ตบุ๊กของคุณ

AWS Sagemaker

ในที่สุดอิน Jupyterคลิก New และเลือก conda_pytorch_p36 จากนั้นคุณก็พร้อมที่จะใช้อินสแตนซ์โน้ตบุ๊กของคุณที่ติดตั้ง Pytorch แล้ว

ต่อไปในบทช่วยสอน PyTorch นี้ เราจะเรียนรู้เกี่ยวกับพื้นฐานของเฟรมเวิร์ก PyTorch

ข้อมูลเบื้องต้นเกี่ยวกับกรอบงาน PyTorch

มาเรียนรู้แนวคิดพื้นฐานของ PyTorch กันก่อนที่จะลงลึก PyTorch ใช้ Tensor สำหรับตัวแปรทุกตัวที่คล้ายกับ ndarray ของ numpy แต่รองรับการคำนวณด้วย GPU ในที่นี้เราจะอธิบายเกี่ยวกับโมเดลเครือข่าย ฟังก์ชันการสูญเสีย Backprop และ Optimizer

โมเดลเครือข่าย

เครือข่ายสามารถสร้างขึ้นได้โดยการแบ่งคลาสย่อย torch.nn มี 2 ​​ส่วนหลักๆ คือ

  1. ส่วนแรกคือการกำหนดพารามิเตอร์และเลเยอร์ที่คุณจะใช้
  2. ส่วนที่สองเป็นงานหลักที่เรียกว่ากระบวนการส่งต่อซึ่งจะรับอินพุตและทำนายผลลัพธ์
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()

ดังที่คุณเห็นข้างต้น คุณสร้างคลาสของ nn.Module ชื่อ Model ประกอบด้วยเลเยอร์ Conv2d 2 ชั้นและเลเยอร์เชิงเส้น เลเยอร์ Conv2d แรกรับอินพุต 3 และรูปร่างเอาต์พุต 20 เลเยอร์ที่สองรับอินพุต 20 และจะสร้างรูปร่างเอาต์พุต 40 เลเยอร์สุดท้ายเป็นเลเยอร์ที่เชื่อมต่อกันอย่างสมบูรณ์ในรูปร่าง 320 และจะสร้าง เอาต์พุต 10

กระบวนการส่งต่อจะนำอินพุตของ X และป้อนไปยังเลเยอร์ Conv1 และดำเนินการฟังก์ชัน ReLU

ในทำนองเดียวกัน มันจะป้อนเลเยอร์ Conv2 ด้วย หลังจากนั้น x จะถูกเปลี่ยนรูปร่างเป็น (-1, 320) และป้อนเข้าสู่ชั้น FC สุดท้าย ก่อนที่คุณจะส่งเอาต์พุต คุณจะต้องใช้ฟังก์ชันการเปิดใช้งาน softmax

กระบวนการย้อนกลับถูกกำหนดโดยอัตโนมัติโดย autograd ดังนั้นคุณเพียงแค่ต้องกำหนดกระบวนการส่งต่อเท่านั้น

ฟังก์ชั่นการสูญเสีย

ฟังก์ชันการสูญเสียใช้เพื่อวัดว่าแบบจำลองการทำนายสามารถทำนายผลลัพธ์ที่คาดหวังได้ดีเพียงใด PyTorch มีฟังก์ชันการสูญเสียมาตรฐานมากมายในโมดูล torch.nn ตัวอย่างเช่น คุณสามารถใช้ Cross-Entropy Loss เพื่อแก้ไขปัญหาการจำแนก PyTorch แบบหลายคลาสได้ ง่ายต่อการกำหนดฟังก์ชันการสูญเสียและคำนวณการสูญเสีย:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

ใช้การคำนวณฟังก์ชันการสูญเสียของคุณเองด้วย PyTorch ได้อย่างง่ายดาย

แบ็คพร็อพ

หากต้องการดำเนินการ backpropagation คุณเพียงแค่เรียก los.backward() ข้อผิดพลาดจะถูกคำนวณ แต่อย่าลืมล้างการไล่ระดับสีที่มีอยู่ด้วย zero_grad()

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

เพิ่มประสิทธิภาพ

torch.optim นำเสนออัลกอริทึมการเพิ่มประสิทธิภาพทั่วไป คุณสามารถกำหนดโปรแกรมเพิ่มประสิทธิภาพด้วยขั้นตอนง่ายๆ ดังนี้:

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

คุณต้องส่งผ่านพารามิเตอร์โมเดลเครือข่ายและอัตราการเรียนรู้ เพื่อที่ว่าในการวนซ้ำทุกครั้ง พารามิเตอร์จะได้รับการอัปเดตหลังจากกระบวนการ backprop

บทความที่เกี่ยวข้อง

การถดถอยอย่างง่ายด้วย PyTorch

มาเรียนรู้การถดถอยอย่างง่ายด้วยตัวอย่าง PyTorch:

ขั้นตอนที่ 1) การสร้างแบบจำลองเครือข่ายของเรา

โมเดลเครือข่ายของเราเป็นเลเยอร์เชิงเส้นธรรมดาที่มีรูปร่างอินพุตและเอาต์พุตเท่ากับ 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)

และเอาต์พุตเครือข่ายควรเป็นเช่นนี้

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

ขั้นตอนที่ 2) ทดสอบข้อมูล

ก่อนที่คุณจะเริ่มกระบวนการฝึกอบรม คุณต้องทราบข้อมูลของเราก่อน คุณสร้างฟังก์ชันสุ่มเพื่อทดสอบโมเดลของเรา ย = x3 บาป(x)+ 3x+0.8 แรนด์(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()

นี่คือแผนภาพกระจายของฟังก์ชันของเรา:

แผนกระจายของการถดถอยอย่างง่ายด้วย PyTorch

ก่อนที่คุณจะเริ่มกระบวนการฝึกอบรม คุณจะต้องแปลงอาร์เรย์ตัวเลขเป็นตัวแปรที่รองรับโดย Torch และ autograd ดังที่แสดงในตัวอย่างการถดถอยของ PyTorch ด้านล่าง

# 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)

ขั้นตอนที่ 3) เครื่องมือเพิ่มประสิทธิภาพและการสูญเสีย

ถัดไป คุณควรกำหนด Optimizer และ Loss Function สำหรับกระบวนการฝึกอบรมของเรา

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

ขั้นตอนที่ 4) การฝึกอบรม

ตอนนี้เรามาเริ่มกระบวนการฝึกอบรมของเรากันดีกว่า ด้วยยุค 250 คุณจะวนซ้ำข้อมูลของเราเพื่อค้นหาค่าที่ดีที่สุดสำหรับไฮเปอร์พารามิเตอร์ของเรา

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()

ขั้นตอนที่ 5) ผลลัพธ์

ดังที่คุณเห็นด้านล่าง คุณดำเนินการ PyTorch regression ด้วยโครงข่ายประสาทเทียมได้สำเร็จ จริงๆ แล้ว ในการวนซ้ำทุกครั้ง เส้นสีแดงในโครงเรื่องจะอัปเดตและเปลี่ยนตำแหน่งให้พอดีกับข้อมูล แต่ในภาพนี้ มันจะแสดงเฉพาะผลลัพธ์สุดท้ายตามที่แสดงในตัวอย่าง PyTorch ด้านล่าง:

แผนภูมิกระจายของผลลัพธ์การถดถอยอย่างง่าย

ตัวอย่างการจำแนกภาพด้วย PyTorch

หนึ่งในวิธีที่นิยมในการเรียนรู้พื้นฐานของ การเรียนรู้ลึก ๆ อยู่ในชุดข้อมูล MNIST ซึ่งเป็น “Hello World” ในการเรียนรู้เชิงลึก ชุดข้อมูลประกอบด้วยตัวเลขที่เขียนด้วยลายมือตั้งแต่ 0 ถึง 9 พร้อมตัวอย่างการฝึกอบรมทั้งหมด 60,000 ตัวอย่างและตัวอย่างการทดสอบ 10,000 ตัวอย่างที่มีป้ายกำกับขนาด 28×28 พิกเซลแล้ว

การจัดหมวดหมู่ภาพด้วย PyTorch

ขั้นตอนที่ 1) ประมวลผลข้อมูลล่วงหน้า

ในขั้นตอนแรกของตัวอย่างการจัดหมวดหมู่ PyTorch คุณจะโหลดชุดข้อมูลโดยใช้โมดูล torchvision

ก่อนที่คุณจะเริ่มกระบวนการฝึกอบรม คุณต้องเข้าใจข้อมูลก่อน Torchvision จะโหลดชุดข้อมูลและแปลงรูปภาพตามข้อกำหนดที่เหมาะสมสำหรับเครือข่าย เช่น รูปร่างและการทำให้รูปภาพเป็นมาตรฐาน

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()

ฟังก์ชั่นการแปลงจะแปลงรูปภาพเป็นเทนเซอร์และทำให้ค่าเป็นมาตรฐาน ฟังก์ชัน torchvision.transforms.MNIST จะดาวน์โหลดชุดข้อมูล (หากไม่มี) ในไดเร็กทอรี ตั้งค่าชุดข้อมูลสำหรับการฝึกหากจำเป็น และดำเนินการกระบวนการเปลี่ยนแปลง

หากต้องการแสดงชุดข้อมูลเป็นภาพ คุณต้องใช้ data_iterator เพื่อรับรูปภาพและป้ายกำกับชุดถัดไป คุณใช้ Matplot เพื่อลงจุดภาพเหล่านี้และป้ายกำกับที่เหมาะสม ดังที่คุณเห็นด้านล่างภาพและป้ายกำกับของเรา

ตัวอย่างการจำแนกภาพด้วย PyTorch

ขั้นตอนที่ 2) การกำหนดค่าโมเดลเครือข่าย

ในตัวอย่าง PyTorch นี้ คุณจะสร้างโครงข่ายประสาทเทียมอย่างง่ายสำหรับการจัดหมวดหมู่รูปภาพของ PyTorch

ที่นี่ เราขอแนะนำอีกวิธีหนึ่งในการสร้างแบบจำลองเครือข่ายใน PyTorch เราจะใช้ nn.Sequential เพื่อสร้างโมเดลลำดับแทนการสร้างคลาสย่อยของ 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)

นี่คือผลลัพธ์ของโมเดลเครือข่ายของเรา

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()
)

คำอธิบายเครือข่าย

  1. ลำดับคือเลเยอร์แรกเป็นเลเยอร์ Conv2D ที่มีรูปร่างอินพุต 1 และรูปร่างเอาต์พุต 10 โดยมีขนาดเคอร์เนล 5
  2. ถัดไป คุณมีเลเยอร์ MaxPool2D
  3. ฟังก์ชั่นการเปิดใช้งาน ReLU
  4. เลเยอร์ Dropout เพื่อลดค่าความน่าจะเป็นต่ำ
  5. จากนั้น Conv2d ที่สองที่มีรูปร่างอินพุต 10 จากเลเยอร์สุดท้ายและรูปร่างเอาต์พุต 20 ด้วยขนาดเคอร์เนล 5
  6. ถัดไปเป็นเลเยอร์ MaxPool2d
  7. ฟังก์ชั่นการเปิดใช้งาน ReLU
  8. หลังจากนั้น คุณจะทำให้เทนเซอร์เรียบก่อนที่จะป้อนเข้าไปในเลเยอร์เชิงเส้น
  9. Linear Layer จะแมปเอาต์พุตของเราที่เลเยอร์ Linear ที่สองพร้อมฟังก์ชันการเปิดใช้งาน softmax

ขั้นตอนที่ 3) ฝึกโมเดล

ก่อนที่คุณจะเริ่มกระบวนการฝึกอบรม จำเป็นต้องตั้งค่าเกณฑ์และฟังก์ชันเครื่องมือเพิ่มประสิทธิภาพ

สำหรับเกณฑ์ คุณจะใช้ CrossEntropyLoss สำหรับ Optimizer คุณจะใช้ SGD ด้วยอัตราการเรียนรู้ 0.001 และโมเมนตัม 0.9 ดังที่แสดงในตัวอย่าง PyTorch ด้านล่าง

import torch.optim as optim

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

กระบวนการส่งต่อจะใช้รูปร่างอินพุตและส่งผ่านไปยังเลเยอร์ Conv2d แรก จากนั้นจะถูกป้อนเข้าสู่ maxpool2d และสุดท้ายจะเข้าสู่ฟังก์ชันการเปิดใช้งาน ReLU กระบวนการเดียวกันนี้จะเกิดขึ้นในเลเยอร์ Conv2d ที่สอง หลังจากนั้นอินพุตจะถูกเปลี่ยนรูปร่างเป็น (-1,320) และป้อนเข้าไปในเลเยอร์ fc เพื่อคาดการณ์เอาต์พุต

ตอนนี้ คุณจะเริ่มกระบวนการฝึกอบรม คุณจะวนซ้ำชุดข้อมูลของเรา 2 ครั้งหรือยุคที่ 2 และพิมพ์การสูญเสียปัจจุบันทุกๆ 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

ในแต่ละยุค ตัวแจงนับจะได้รับอินพุตอันดับถัดไปและป้ายกำกับที่เกี่ยวข้อง ก่อนที่เราจะป้อนอินพุตให้กับโมเดลเครือข่ายของเรา เราจำเป็นต้องล้างการไล่ระดับสีก่อนหน้า สิ่งนี้จำเป็นเนื่องจากหลังจากกระบวนการย้อนกลับ (กระบวนการ backpropagation) การไล่ระดับสีจะถูกสะสมแทนที่จะถูกแทนที่ จากนั้น เราจะคำนวณความสูญเสียจากผลลัพธ์ที่คาดการณ์ไว้จากผลลัพธ์ที่คาดหวัง หลังจากนั้น เราจะทำการ backpropagation เพื่อคำนวณการไล่ระดับสี และสุดท้าย เราจะอัปเดตพารามิเตอร์

นี่คือผลลัพธ์ของกระบวนการฝึกอบรม

[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

ขั้นตอนที่ 4) ทดสอบโมเดล

หลังจากที่คุณฝึกโมเดลของเราแล้ว คุณจะต้องทดสอบหรือประเมินด้วยชุดรูปภาพอื่นๆ

เราจะใช้ตัววนซ้ำสำหรับ test_loader และจะสร้างชุดของรูปภาพและป้ายกำกับที่จะส่งต่อไปยังโมเดลที่ได้รับการฝึก ผลลัพธ์ที่คาดการณ์ไว้จะถูกแสดงและเปรียบเทียบกับผลลัพธ์ที่คาดหวัง

#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()

ตัวอย่างการจำแนกภาพด้วย PyTorch

สรุป

  • PyTorch เป็นไฟฉายแบบโอเพ่นซอร์ส เครื่องเรียนรู้ ห้องสมุดสำหรับ การประมวลผลภาษาธรรมชาติ การใช้ Python.
  • ข้อดีของ PyTorch: 1) Simple Library, 2) Dynamic Computational Graph, 3) ประสิทธิภาพที่ดีขึ้น, 4) Native Python
  • PyTorch ใช้ Tensor สำหรับทุกตัวแปรที่คล้ายกับ ndarray ของ numpy แต่รองรับการคำนวณ GPU
  • หนึ่งในวิธีที่ได้รับความนิยมในการเรียนรู้พื้นฐานของการเรียนรู้เชิงลึกคือการใช้ชุดข้อมูล MNIST

ที่คุณอาจชอบ: