PyTorบทช่วยสอน

พีคืออะไรTorช?

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

การรู้ว่า Py คืออะไรTorch เป็นการนำเสนอภาพรวมที่สมดุลเกี่ยวกับจุดแข็งและจุดอ่อนของมัน

PyTorข้อดีและข้อเสีย

ต่อไปนี้คือข้อดีและข้อเสียของ PyTorCH:

ข้อดีของ PyTorch

1. ห้องสมุดอย่างง่าย
   PyTorโค้ด ch นั้นเรียบง่าย เข้าใจง่าย และคุณสามารถใช้งานไลบรารีได้ทันที ตัวอย่างเช่น ลองดูโค้ดตัวอย่างด้านล่างนี้:

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

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

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

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

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

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

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

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

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

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

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

PyTorนอกจากนี้ ch ยังใช้การเขียนโปรแกรมเชิงคำสั่ง (Imperative Programming) ซึ่งมีความยืดหยุ่นมากกว่า ดังนั้นจึงสามารถพิมพ์ค่าเทนเซอร์ออกมาได้ในระหว่างกระบวนการคำนวณ

ข้อเสียของ PyTorch

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

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

PyTorch เทียบกับ TensorFlow

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

การติดตั้ง PyTorch

ลินุกซ์

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

pip3 install --upgrade torch torchvision

AWS Sagemaker

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

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

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

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

ถัดไปใน Py นี้Torch tutorial เราจะเรียนรู้เกี่ยวกับ PyTorพื้นฐานของเฟรมเวิร์ก ch

เมื่อติดตั้งระบบเสร็จเรียบร้อยแล้ว ขั้นตอนต่อไปคือการใช้งาน API

PyTorโครงสร้างพื้นฐานของเฟรมเวิร์ก ch

มาเรียนรู้แนวคิดพื้นฐานของ Python กันเถอะTorch ก่อนที่เราจะเจาะลึกลงไป 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 ดังนั้นคุณเพียงแค่ต้องกำหนดกระบวนการส่งต่อเท่านั้น

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

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

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

การใช้ฟังก์ชันคำนวณค่าความสูญเสียของคุณเองกับ Python นั้นง่ายมากTorCH

แบ็คพร็อพ

หากต้องการดำเนินการ 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

วิธีที่ง่ายและได้ผลที่สุดในการเรียนรู้ API คือการใช้ตัวอย่างขนาดเล็กที่แสดงการทำงานตั้งแต่ต้นจนจบ

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

มาเรียนรู้การหาค่าการถดถอยอย่างง่ายด้วย Python กันเถอะTorตัวอย่าง ch:

ขั้นตอนที่ 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) ทดสอบข้อมูล

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

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

ก่อนเริ่มกระบวนการฝึกอบรม คุณต้องแปลงอาร์เรย์ NumPy ให้เป็นตัวแปรที่รองรับโดย NumPy ก่อน Torch และ autograd ดังแสดงใน Py ด้านล่างTorตัวอย่างการวิเคราะห์การถดถอย 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)

ขั้นตอนที่ 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) ผลลัพธ์

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

การถดถอยเป็นการวอร์มอัพ ส่วนการจำแนกภาพเป็นการฝึกฝนทักษะการเรียนรู้เชิงลึกของ PyTorCH

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

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

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

ในขั้นตอนแรกของ Py นี้Torตัวอย่างการจำแนกประเภท ch คุณจะโหลดชุดข้อมูลโดยใช้โมดูล 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 เพื่อลงจุดภาพเหล่านี้และป้ายกำกับที่เหมาะสม ดังที่คุณเห็นด้านล่างภาพและป้ายกำกับของเรา

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

ตอนนี้ใน Py นี้Torตัวอย่างเช่น คุณจะสร้างโครงข่ายประสาทเทียมอย่างง่ายสำหรับ PythonTorการจำแนกภาพ ch

ในที่นี้ เราขอแนะนำอีกวิธีหนึ่งในการสร้างแบบจำลองเครือข่ายในภาษา PythonTorบทที่ 1 เราจะใช้ 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 ดังแสดงในไฟล์ Py ด้านล่างTorตัวอย่างเช่น ch

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

คำถามที่พบบ่อย