需要知道的程式碼實現細節
這些模組在 NN 中是通用的，後面的學習是在此基礎上的拓展
迴圈總訓練函數#
##### %matplotlib inline
import torch
import torchvision
from torch.utils import data
from torchvision import transforms
from d2l import torch as d2l
from IPython import display
def get_dataloader_workers():
"""使用4個進程來讀取的數據"""
return 4
def load_data_fashion_mnist(batch_size, resize=None):
"""下載Fashion-MNIST數據集，然後將其加載到內存中"""
trans = [transforms.ToTensor()]
if resize:
trans.insert(0,transforms.Resize(resize)) # 如果有Resize參數傳進來，就進行resize操作
trans = transforms.Compose(trans)
mnist_train = torchvision.datasets.FashionMNIST(root="01_data/01_DataSet_FashionMNIST",train=True,transform=trans,download=True)
mnist_test = torchvision.datasets.FashionMNIST(root="01_data/01_DataSet_FashionMNIST",train=False,transform=trans,download=True)
return (data.DataLoader(mnist_train, batch_size, shuffle=True, num_workers=get_dataloader_workers()),
data.DataLoader(mnist_test, batch_size, shuffle=False, num_workers=get_dataloader_workers()))
batch_size = 256
train_iter, test_iter = load_data_fashion_mnist(batch_size) # 返回訓練集、測試集的迭代器
num_inputs = 784
num_outputs = 10
w = torch.normal(0,0.01,size=(num_inputs,num_outputs),requires_grad=True)
b = torch.zeros(num_outputs,requires_grad=True)
def softmax(X):
X_exp = torch.exp(X) # 每個都進行指數運算
partition = X_exp.sum(1,keepdim=True)
return X_exp / partition # 這裡應用了廣播機制
# 實現softmax回歸模型
def net(X):
return softmax(torch.matmul(X.reshape((-1,w.shape[0])),w)+b) # -1為默認的批量大小，表示有多少個圖片，每個圖片用一維的784列個元素表示
def cross_entropy(y_hat, y):
return -torch.log(y_hat[range(len(y_hat)),y]) # y_hat[range(len(y_hat)),y]為把y的標號列表對應的值拿出來。傳入的y要是最大概率的標號
def accuracy(y_hat,y):
"""計算預測正確的數量"""
if len(y_hat.shape) > 1 and y_hat.shape[1] > 1: # y_hat.shape[1]>1表示不止一個類別，每個類別有各自的概率
y_hat = y_hat.argmax(axis=1) # y_hat.argmax(axis=1)為求行最大值的索引
cmp = y_hat.type(y.dtype) == y # 先判斷邏輯運算符==，再賦值給cmp，cmp為布爾類型的數據
return float(cmp.type(y.dtype).sum()) # 獲得y.dtype的類型作為傳入參數，將cmp的類型轉為y的類型（int型），然後再求和
# 可以評估在任意模型net的準確率
def evaluate_accuracy(net,data_iter):
"""計算在指定數據集上模型的精度"""
if isinstance(net,torch.nn.Module): # 如果net模型是torch.nn.Module實現的神經網絡的話，將它變成評估模式
net.eval() # 將模型設置為評估模式
metric = Accumulator(2) # 正確預測數、預測總數，metric為累加器的實例化對象，裡面存了兩個數
for X, y in data_iter:
metric.add(accuracy(net(X),y),y.numel()) # net(X)將X輸入模型，獲得預測值。y.numel()為樣本總數
return metric[0] / metric[1] # 分類正確的樣本數 / 總樣本數
# Accumulator實例中創建了2個變量，用於分別存儲正確預測的數量和預測的總數量
class Accumulator:
"""在n個變量上累加"""
def __init__(self,n):
self.data = [0.0] * n
def add(self, *args):
self.data = [a+float(b) for a,b in zip(self.data,args)] # zip函數把兩個列表第一個位置元素打包、第二個位置元素打包....
def reset(self):
self.data = [0.0] * len(self.data)
def __getitem__(self,idx):
return self.data[idx]
# 訓練函數
def train_epoch_ch3(net, train_iter, loss, updater):
if isinstance(net, torch.nn.Module):
net.train() # 開啟訓練模式
metric = Accumulator(3)
for X, y in train_iter:
y_hat = net(X)
l = loss(y_hat,y) # 計算損失
if isinstance(updater, torch.optim.Optimizer): # 如果updater是pytorch的優化器的話
updater.zero_grad()
l.mean().backward() # 這裡對loss取了平均值出來
updater.step()
metric.add(float(l)*len(y),accuracy(y_hat,y),y.size().numel()) # 總的訓練損失、樣本正確數、樣本總數
else:
l.sum().backward()
updater(X.shape[0])
metric.add(float(l.sum()),accuracy(y_hat,y),y.numel())
return metric[0] / metric[2], metric[1] / metric[2] # 所有loss累加除以樣本總數，總的正確個數除以樣本總數
class Animator:
def __init__(self, xlabel=None, ylabel=None, legend=None, xlim=None,
ylim=None, xscale='linear',yscale='linear',
fmts=('-','m--','g-.','r:'),nrows=1,ncols=1,
figsize=(3.5,2.5)):
if legend is None:
legend = []
d2l.use_svg_display()
self.fig, self.axes = d2l.plt.subplots(nrows,ncols,figsize=figsize)
if nrows * ncols == 1:
self.axes = [self.axes,]
self.config_axes = lambda: d2l.set_axes(self.axes[0],xlabel,ylabel,xlim,ylim,xscale,yscale,legend)
self.X, self.Y, self.fmts = None, None, fmts
def add(self, x, y):
if not hasattr(y, "__len__"):
y = [y]
n = len(y)
if not hasattr(x, "__len__"):
x = [x] * n
if not self.X:
self.X = [[] for _ in range(n)]
if not self.Y:
self.Y = [[] for _ in range(n)]
for i, (a,b) in enumerate(zip(x,y)):
if a is not None and b is not None:
self.X[i].append(a)
self.Y[i].append(b)
self.axes[0].cla()
for x, y, fmt in zip(self.X, self.Y, self.fmts):
self.axes[0].plot(x, y, fmt)
self.config_axes()
display.display(self.fig)
display.clear_output(wait=True)
# 總訓練函數
def train_ch3(net,train_iter,test_iter,loss,num_epochs,updater):
animator = Animator(xlabel='epoch',xlim=[1,num_epochs],ylim=[0.3,0.9],
legend=['train loss','train acc','test acc'])
for epoch in range(num_epochs): # 變量num_epochs遍數據
train_metrics = train_epoch_ch3(net,train_iter,loss,updater) # 返回兩個值，一個總損失、一個總正確率
test_acc = evaluate_accuracy(net, test_iter) # 測試數據集上評估精度，僅返回一個值，總正確率
animator.add(epoch+1,train_metrics+(test_acc,)) # train_metrics+(test_acc,) 僅將兩個值的正確率相加，
train_loss, train_acc = train_metrics
# 小批量隨機梯度下降來優化模型的損失函數
lr = 0.1
def updater(batch_size):
return d2l.sgd([w,b],lr,batch_size)
num_epochs = 100
train_ch3(net,train_iter,test_iter,cross_entropy,num_epochs,updater)
預測數據#
def predict_ch3(net,test_iter,n=12):
for X, y in test_iter:
break # 僅拿出一批六個數據
trues = d2l.get_fashion_mnist_labels(y)
preds = d2l.get_fashion_mnist_labels(net(X).argmax(axis=1))
titles = [true + '\n' + pred for true, pred in zip(trues,preds)]
d2l.show_images(X[0:n].reshape((n,28,28)),1,n,titles=titles[0:n])
predict_ch3(net,test_iter)