DataWhaleチームパンチ学習キャンプtask04-3 LeNet

• lenetモデルが導入します
• lenetネットワーク構造
• Lenet用いた画像認識データセット-fashion-mnist

畳み込みニューラルネットワークを
完全に接続された層を使用する場合の制限：

• 同じ列の隣接するピクセルの画像は離れて、このベクターであってもよいです。彼らは、パターン認識モデルが困難な場合がある構成します。
• 接続層の完全なモデルを用いて、入力画像のサイズが大きいため、容易に大きすぎにつながります。

畳み込み層を使用する利点：

• コンボリューション入力形状保持層。
• 入力層の畳み込みは、同一の畳み込み演算とスライディングウィンドウによって形成されるオーバーサイズパラメータを避けるために、異なる位置で繰り返されます。

LeNetモデルの
2つの部分にLeNet層ブロックとコンボリューションブロック層が完全に接続されています。我々の下にはこれら二つのモジュールについて説明します。

基本単位電池層の平均アクセス層畳み込みにおけるレイヤブロック畳み込み：畳み込み層は、線およびローカルオブジェクトのような空間パターンで画像を識別するのに役立つ、層後の平均細胞層は畳み込みを低減するために使用されます位置の感度。

二つのそのような基本単位の階層ブロックコンボリューションを繰り返し設定を積層されています。コンボリューションブロック層は、各層は、畳み込み使用
シグモイド活性化関数と出力を使用して、ウィンドウ。最初の畳み込み層出力チャネルは、第二の畳み込み層16への出力チャンネルの数を増加させ、6です。

完全に接続されたレイヤブロックが完全に接続3層を含みます。10は、出力クラスの数が出力数、そのそれぞれ120,84及び10、。

今、私たちは、シーケンシャルクラスによってLeNetモデルを実現するために来ます。

#import
import sys
sys.path.append("/home/kesci/input")
import d2lzh1981 as d2l
import torch
import torch.nn as nn
import torch.optim as optim
import time

#net
class Flatten(torch.nn.Module):  #展平操作
    def forward(self, x):
        return x.view(x.shape[0], -1)

class Reshape(torch.nn.Module): #将图像大小重定型
    def forward(self, x):
        return x.view(-1,1,28,28)      #(B x C x H x W)
    
net = torch.nn.Sequential(     #Lelet                                                  
    Reshape(),
    nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, padding=2), #b*1*28*28  =>b*6*28*28
    nn.Sigmoid(),                                                       
    nn.AvgPool2d(kernel_size=2, stride=2),                              #b*6*28*28  =>b*6*14*14
    nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5),           #b*6*14*14  =>b*16*10*10
    nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),                              #b*16*10*10  => b*16*5*5
    Flatten(),                                                          #b*16*5*5   => b*400
    nn.Linear(in_features=16*5*5, out_features=120),
    nn.Sigmoid(),
    nn.Linear(120, 84),
    nn.Sigmoid(),
    nn.Linear(84, 10)
)

次に、我々は、単一チャンネルデータを構成する各層の形状からの出力で計算するために、サンプル28、及び層によって、フロント層の高さと幅です。

#print
X = torch.randn(size=(1,1,28,28), dtype = torch.float32)
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__,'output shape: \t',X.shape)

変形出力形状：torch.Size（[1、1、28、28]）
Conv2d出力形状：torch.Size（[1、6、28、28]）
シグモイド出力形状：torch.Size（[1、6、28 、28]）
AvgPool2d出力形状：torch.Size（[1、6、14、14]）
Conv2d出力形状：torch.Size（[1、16、10、10]）
シグモイド出力形状：torch.Size（[1 、16、10、10]）
AvgPool2d出力形状：torch.Size（[1、16、5、5]）
平坦化出力形状：torch.Size（[1、400]）
リニア出力形状：torch.Size（[1 、120]）
シグモイド出力形状：torch.Size（[1、120]）
線形出力形状：torch.Size（[1、84]）
シグモイド出力形状：torch.Size（[1、84]）
リニア出力形状： torch.Size（[1]、[10]）

これは、入力層ブロック畳み込み高さで見ることができ、幅は、層毎に減少します。畳み込み層の高さと幅の使用は、それによって層のプールの高さと幅が半減するが、高さと幅、それぞれ4を減少が、5畳み込みカーネルである1から16までのチャンネルの数。層は完全にはカテゴリ10の画像数になるまで、出力層の数を減らす接続されています。

データとモデル・トレインへのアクセス
私たちは、以下のLeNetモデルを実現しています。ファッション-MNIST我々はまだ、訓練データセットとして使用します。

# 数据
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(
    batch_size=batch_size, root='/home/kesci/input/FashionMNIST2065')
print(len(train_iter))#235

、より多くの画像データの表示への画像データの追加部分を参照するために読者を可能にするために

#数据展示
import matplotlib.pyplot as plt
def show_fashion_mnist(images, labels):
    d2l.use_svg_display()
    # 这里的_表示我们忽略（不使用）的变量
    _, figs = plt.subplots(1, len(images), figsize=(12, 12))
    for f, img, lbl in zip(figs, images, labels):
        f.imshow(img.view((28, 28)).numpy())
        f.set_title(lbl)
        f.axes.get_xaxis().set_visible(False)
        f.axes.get_yaxis().set_visible(False)
    plt.show()

for Xdata,ylabel in train_iter:
    break
X, y = [], []
for i in range(10):
    print(Xdata[i].shape,ylabel[i].numpy())
    X.append(Xdata[i]) # 将第i个feature加到X中
    y.append(ylabel[i].numpy()) # 将第i个label加到y中
show_fashion_mnist(X, y)

torch.Size（[1、28、28]）。3
torch.Size（[1、28、28]）。8
torch.Size（[1、28、28]）。1
torch.Size（[1、28、28] ）。4
torch.Size（[1、28、28]）0
torch.Size（[1、28、28]）0
torch.Size（[1、28、28]）。4
torch.Size（[1、28、 28]）。9
torch.Size（[1、28、28]）。4
torch.Size（[1、28、28]）。7

、多層パーセプトロンより機密複雑なコンピューティング畳み込みニューラルネットワークとして、推奨算出GPUアクセラレーションを使用して。それ以外の場合は、まだCPUを使用し、0：成功した利用CUDA場合、我々は、GPUを使用できるかどうかを確認してください。

# This function has been saved in the d2l package for future use
#use GPU
def try_gpu():
    """If GPU is available, return torch.device as cuda:0; else return torch.device as cpu."""
    if torch.cuda.is_available():
        device = torch.device('cuda:0')
    else:
        device = torch.device('cpu')
    return device

device = try_gpu()
device

デバイス（種類= 'CPU'）

私たちは、data_iterの精度にネットモデル・データ・セットを計算するのに使用されるevaluate_accuracy機能を実現します。

#计算准确率
'''
(1). net.train()
  启用 BatchNormalization 和 Dropout，将BatchNormalization和Dropout置为True
(2). net.eval()
不启用 BatchNormalization 和 Dropout，将BatchNormalization和Dropout置为False
'''

def evaluate_accuracy(data_iter, net,device=torch.device('cpu')):
    """Evaluate accuracy of a model on the given data set."""
    acc_sum,n = torch.tensor([0],dtype=torch.float32,device=device),0
    for X,y in data_iter:
        # If device is the GPU, copy the data to the GPU.
        X,y = X.to(device),y.to(device)
        net.eval()
        with torch.no_grad():
            y = y.long()
            acc_sum += torch.sum((torch.argmax(net(X), dim=1) == y))  #[[0.2 ,0.4 ,0.5 ,0.6 ,0.8] ,[ 0.1,0.2 ,0.4 ,0.3 ,0.1]] => [ 4 , 2 ]
            n += y.shape[0]
    return acc_sum.item()/n

私たちは、モデルのトレーニングに使用する関数のtrain_ch5を定義します。

#训练函数
def train_ch5(net, train_iter, test_iter,criterion, num_epochs, batch_size, device,lr=None):
    """Train and evaluate a model with CPU or GPU."""
    print('training on', device)
    net.to(device)
    optimizer = optim.SGD(net.parameters(), lr=lr)
    for epoch in range(num_epochs):
        train_l_sum = torch.tensor([0.0],dtype=torch.float32,device=device)
        train_acc_sum = torch.tensor([0.0],dtype=torch.float32,device=device)
        n, start = 0, time.time()
        for X, y in train_iter:
            net.train()
            
            optimizer.zero_grad()
            X,y = X.to(device),y.to(device) 
            y_hat = net(X)
            loss = criterion(y_hat, y)
            loss.backward()
            optimizer.step()
            
            with torch.no_grad():
                y = y.long()
                train_l_sum += loss.float()
                train_acc_sum += (torch.sum((torch.argmax(y_hat, dim=1) == y))).float()
                n += y.shape[0]
        test_acc = evaluate_accuracy(test_iter, net,device)
        print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f, '
              'time %.1f sec'
              % (epoch + 1, train_l_sum/n, train_acc_sum/n, test_acc,
                 time.time() - start))

上記、およびランダム初期化ザビエルを使用して：我々はデバイス装置（0 CPUやCUDA）に対応するモデルパラメータを再初期化します。損失関数とトレーニングアルゴリズムは依然としてクロスエントロピー損失関数と確率的勾配降下法の少量を使用しています。

# 训练
lr, num_epochs = 0.9, 10

def init_weights(m):
    if type(m) == nn.Linear or type(m) == nn.Conv2d:
        torch.nn.init.xavier_uniform_(m.weight)

net.apply(init_weights)
net = net.to(device)

criterion = nn.CrossEntropyLoss()   #交叉熵描述了两个概率分布之间的距离，交叉熵越小说明两者之间越接近
train_ch5(net, train_iter, test_iter, criterion,num_epochs, batch_size,device, lr)

CPUの上でトレーニング
エポック1、損失0.0091、0.100 ACC列車、0.168 ACC試験時間21.6秒
エポック2、損失0.0065、0.355 ACC列車、0.599 ACC試験時間21.5秒
エポック3、損失0.0035、0.651 ACC列車、0.665 ACC試験時間21.8秒
エポック4、損失0.0028、0.717 ACC列車、0.723 ACC試験時間21.7秒
エポック5、損失0.0025、0.746 ACC列車、0.753 ACC試験時間21.4秒
エポック6、損失0.0023、0.767 ACC列車、試験ACC 0.754、時間21.5秒
エポック7、損失0.0022、0.782 ACC列車、0.785 ACC試験時間21.3秒
エポック8、損失0.0021、0.798 ACC列車、0.791 ACC試験時間21.8秒
エポック9、損失0.0019、0.811 ACC列車、テスト0.790 ACC、時間22.0秒の
エポック10、損失0.0019、0.821 ACC列車、試験ACC 0.804、時間22.1秒

# test
for testdata,testlabe in test_iter:
    testdata,testlabe = testdata.to(device),testlabe.to(device)
    break
print(testdata.shape,testlabe.shape)
net.eval()
y_pre = net(testdata)
print(torch.argmax(y_pre,dim=1)[:10])
print(testlabe[:10])

torch.Size（[256、1、28、28]）torch.Size（[256]）
テンソル（[9、2、1、1、6、1、2、6、5、7]）
テンソル（[9 、2、1、1、6、1、4、6、5、7]）

概要：
畳み込みニューラルネットワークとの畳み込みは、ネットワーク層です。LeNet交互層と最大プール畳み込みコンタクト層画像分類のための完全に接続層。