知っておくべきコードの実装詳細
これらのモジュールは 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はデフォルトのバッチサイズで、画像の数を表し、各画像は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は累積器のインスタンス化オブジェクトで、2つの数が格納されています
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関数は2つのリストの最初の位置の要素をパッケージ化し、2番目の位置の要素をパッケージ化します....
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() # ここで損失の平均値を取ります
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] # すべての損失を合計し、サンプルの総数で割ります。総正しい数をサンプルの総数で割ります
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) # 2つの値を返します、1つは総損失、もう1つは総正確度
test_acc = evaluate_accuracy(net, test_iter) # テストデータセット上で精度を評価し、1つの値を返します、総正確度
animator.add(epoch+1,train_metrics+(test_acc,)) # train_metrics+(test_acc,)は2つの値の正確度を加算します
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 # 1バッチの6つのデータのみを取得します
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)