07-GoogLenet 图像分类

Inception 结构的主要思路是用密集成分来近似最优的局部稀疏结构。原始Inception 结构如下图所示：

 

 　　显然从上图中可以看出，原始Inception 结构采用 1 × 1、 3 × 3和 5 × 5三种卷积核的卷积层进行并行提取特征，这可以加大网络模型的宽度，不同大小的卷积核也就意味着原始Inception 结构可以获取到不同大小的感受野，上图中的最后拼接就是将不同尺度特征进行深度融合。

　　同时在原始Inception 结构之所以卷积核大小采用1、3和5，主要是为了方便对齐。设定卷积步长stride=1之后，只要分别设定pad=0、1、2，那么卷积之后便可以得到相同维度的特征，然后这些特征就可以直接深度融合了。

　　最后文章说很多地方都表明pooling挺有效，所以原始Inception结构里面也加入了最大池化层来降低网络模型参数。特别重要的是网络越到后面，特征越抽象，而且每个特征所涉及的感受野也更大了，因此随着层数的增加，GoogLeNet中3x3和5x5卷积的比例也要增加。

　　但是原始Inception结构中 5 × 5 、卷积核仍然会带来巨大的计算量。降低 5 × 5 卷积核带来的计算量，GoogLeNet中借鉴了NIN(Network in Network)的思想使用 1 × 1 卷积层与 5 × 5卷积层相结合来实现参数降维。

　　对于 1 × 1卷积层与 5 × 5卷积层实现参数降维，在这里也举一个简单的例子进行说明。假如上一层的输出为 100 × 100 × 128，经过具有 256个输出的5×5卷积层之后(stride=1，pad=2)，输出数据为 100 × 100 × 256。其中，那么卷积层的参数为 128 × 5 × 5 × 256。此时如果上一层输出先经过具有 32个输出的 1 × 1卷积层，再经过具有 256个输出的 5 × 5卷积层，那么最终的输出数据仍为为 100 × 100 × 256，但卷积参数量已经减少为 128 × 1 × 1 × 32 + 32 × 5 × 5 × 256，相比之下参数大约减少了4倍。

　　因此在 3 × 3和 5 × 5卷积层之前加入合适的 1 × 1卷积层可以在一定程度上减少模型参数，那么在GoogLeNet中基础Inception结构也就做出了相应的改进，改进后的Inception结构如下图所示。

 GoogLeNet的整体网络架构如下：

 

 参考：https://blog.csdn.net/qq_30091945/article/details/105128249

GoogLenet的pytorch实现：

import torch
import torch.nn as nn
import torch.nn.functional as F

class BasicConv2d(nn.Module):
    def __init__(self,in_channels, out_channels, kernel, stride=1, padding=0):
        super(BasicConv2d, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels,
                              kernel_size=kernel, stride=stride, padding=padding,
                              bias=False)
        self.bn = nn.BatchNorm2d(out_channels, eps=0.001)
 
    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        return F.relu(x, inplace=True)
 
'''
in_channels         输入数据的通道
out_channels_1x1    1*1卷积深度
out_channels_1x1_3  3*3前面的1*1卷积深度
out_channels_3x3    3*3卷积深度
out_channels_1x1_5  5*5前面的1*1卷积深度
out_channels_5x5    5*5卷积深度
out_channels_pool   池化后面的1*1卷积深度
'''
class Inception(nn.Module):
    def __init__(self, in_channels, out_channels_1x1,
                 out_channels_1x1_3,  out_channels_3x3,
                 out_channels_1x1_5, out_channels_5x5,
                 out_channels_pool ):
        super(Inception, self).__init__()
        ##第一条线
        self.branch1x1 = BasicConv2d(in_channels, out_channels_1x1, 1)
 
        ##第二条线
        self.branch3x3 = nn.Sequential(
            BasicConv2d(in_channels, out_channels_1x1_3, 1),
            BasicConv2d(out_channels_1x1_3, out_channels_3x3, 3, 1, 1)
        )
 
        ##第三条线
        self.branch5x5 = nn.Sequential(
            BasicConv2d(in_channels, out_channels_1x1_5, 1),
            BasicConv2d(out_channels_1x1_5, out_channels_5x5, 5, 1, 2)
        )
 
        ##第四条线
        self.branch_pool = nn.Sequential(
            nn.MaxPool2d(kernel_size=3, stride=1, padding=1),
            BasicConv2d(in_channels, out_channels_pool, 1)
        )
 
    def forward(self, x):
        branch1x1 = self.branch1x1(x)
 
        branch3x3 = self.branch3x3(x)
 
        branch5x5 = self.branch5x5(x)
 
        branch_pool = self.branch_pool(x)
 
        output = [branch1x1, branch3x3, branch5x5, branch_pool]
        return torch.cat(output, 1)
    
class GoogLeNet(nn.Module):
    def __init__(self, in_channels=3, num_class=10):
        super(GoogLeNet, self).__init__()
        ##第 1 个模块
        self.block1 = nn.Sequential(
            nn.Conv2d(in_channels, 64, 7, 2, 3),
            nn.MaxPool2d(3, 2, 1)
        )
        ##第 2 个模块
        self.block2 = nn.Sequential(
            nn.Conv2d(64, 192, 3, 1, 1),
            nn.Conv2d(192, 192, 3, 1, 1),
            nn.MaxPool2d(3, 2, 1)
        )
        ##第 3 个模块
        self.block3 = nn.Sequential(
            Inception(192, 64, 96, 128, 16, 32, 32),
            Inception(256, 128, 128, 192, 32, 96, 64),
            nn.MaxPool2d(3, 2, 1)
        )
        ##第 4 个模块
        self.block4 = nn.Sequential(
            Inception(480, 192, 96, 208, 16, 48, 64),
            Inception(512, 160, 112, 224, 24, 64, 64),  #这里究极体会输出
            Inception(512, 128, 128, 256, 24, 64, 64),
            Inception(512, 112, 144, 288, 32, 64, 64),
            Inception(528, 256, 160, 320, 32, 128, 128), #这里究极体会输出
            nn.MaxPool2d(3, 2, 1)
        )
        ##第 5 个模块
        self.block5 = nn.Sequential(
            Inception(832, 256, 160, 320, 32, 128, 128),
            Inception(832, 384, 192, 384, 48, 128, 128),
            nn.AvgPool2d(7, 1)
        )
        self.classifier = nn.Sequential(
            nn.Dropout(0.4),
            nn.Linear(1024, num_class),
            # nn.Sigmoid(1024,out_channels)
        )
 
    def forward(self, x):
        x = self.block1(x)
        x = self.block2(x)
        x = self.block3(x)
        x = self.block4(x)
        x = self.block5(x)
 
        x = torch.reshape(x, (x.shape[0], -1))
        x = self.classifier(x)
 
        return x

classfyNet_main.py

import torch
from torch.utils.data import DataLoader
from torch import nn, optim
from torchvision import datasets, transforms
from torchvision.transforms.functional import InterpolationMode

from matplotlib import pyplot as plt


import time

from Lenet5 import Lenet5_new
from Resnet18 import ResNet18,ResNet18_new
from AlexNet import AlexNet
from Vgg16 import VGGNet16
from Densenet import DenseNet121, DenseNet169, DenseNet201, DenseNet264

from NIN import NIN_Net
from GoogleNet import GoogLeNet

def main():
    
    print("Load datasets...")
    
    # transforms.RandomHorizontalFlip(p=0.5)---以0.5的概率对图片做水平横向翻转
    # transforms.ToTensor()---shape从(H,W,C)->(C,H,W), 每个像素点从(0-255)映射到(0-1):直接除以255
    # transforms.Normalize---先将输入归一化到(0,1),像素点通过"(x-mean)/std",将每个元素分布到(-1,1)
    transform_train = transforms.Compose([
                        transforms.Resize((224, 224), interpolation=InterpolationMode.BICUBIC),
                        # transforms.RandomCrop(32, padding=4),  # 先四周填充0，在吧图像随机裁剪成32*32
                        transforms.RandomHorizontalFlip(p=0.5),
                        transforms.ToTensor(),
                        transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
                    ])

    transform_test = transforms.Compose([
                        transforms.Resize((224, 224), interpolation=InterpolationMode.BICUBIC),
                        # transforms.RandomCrop(32, padding=4),  # 先四周填充0，在吧图像随机裁剪成32*32
                        transforms.ToTensor(),
                        transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
                    ])
    
    # 内置函数下载数据集
    train_dataset = datasets.CIFAR10(root="./data/Cifar10/", train=True, 
                                     transform = transform_train,
                                     download=True)
    test_dataset = datasets.CIFAR10(root = "./data/Cifar10/", 
                                    train = False, 
                                    transform = transform_test,
                                    download=True)
    
    print(len(train_dataset), len(test_dataset))
    
    Batch_size = 64
    train_loader = DataLoader(train_dataset, batch_size=Batch_size,  shuffle = True, num_workers=4)
    test_loader = DataLoader(test_dataset, batch_size = Batch_size, shuffle = False, num_workers=4)
    
    # 设置CUDA
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

    # 初始化模型
    # 直接更换模型就行，其他无需操作
    # model = Lenet5_new().to(device)
    # model = ResNet18().to(device)
    # model = ResNet18_new().to(device)
    # model = VGGNet16().to(device)
    # model = DenseNet121().to(device)
    # model  = DenseNet169().to(device)

    # model = NIN_Net().to(device)
    
    model = GoogLeNet().to(device)
    
    # model = AlexNet(num_classes=10, init_weights=True).to(device)
    print(" GoogLeNet train...")
      
    # 构造损失函数和优化器
    criterion = nn.CrossEntropyLoss() # 多分类softmax构造损失
    # opt = optim.SGD(model.parameters(), lr=0.01, momentum=0.8, weight_decay=0.001)
    opt = optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=0.0005)
    
    # 动态更新学习率 ------每隔step_size : lr = lr * gamma
    schedule = optim.lr_scheduler.StepLR(opt, step_size=10, gamma=0.6, last_epoch=-1)
    
    # 开始训练
    print("Start Train...")

    epochs = 100
   
    loss_list = []
    train_acc_list =[]
    test_acc_list = []
    epochs_list = []
    
    for epoch in range(0, epochs):
         
        start = time.time()
        
        model.train()
        
        running_loss = 0.0
        batch_num = 0
        
        for i, (inputs, labels) in enumerate(train_loader):
            
            inputs, labels = inputs.to(device), labels.to(device)
            
            # 将数据送入模型训练
            outputs = model(inputs)
            # 计算损失
            loss = criterion(outputs, labels).to(device)
            
            # 重置梯度
            opt.zero_grad()
            # 计算梯度，反向传播
            loss.backward()
            # 根据反向传播的梯度值优化更新参数
            opt.step()
            
            # 100个batch的 loss 之和
            running_loss += loss.item()
            # loss_list.append(loss.item())
            batch_num+=1
            
            
        epochs_list.append(epoch)
            
        # 每一轮结束输出一下当前的学习率 lr
        lr_1 = opt.param_groups[0]['lr']
        print("learn_rate:%.15f" % lr_1)
        schedule.step()
        
        end = time.time()
        print('epoch = %d/100, batch_num = %d, loss = %.6f, time = %.3f' % (epoch+1, batch_num, running_loss/batch_num, end-start))
        running_loss=0.0    
        
        # 每个epoch训练结束，都进行一次测试验证
        model.eval()
        train_correct = 0.0
        train_total = 0

        test_correct = 0.0
        test_total = 0
        
         # 训练模式不需要反向传播更新梯度
        with torch.no_grad():
            
            # print("=======================train=======================")
            for inputs, labels in train_loader:
                inputs, labels = inputs.to(device), labels.to(device)
                outputs = model(inputs)

                pred = outputs.argmax(dim=1)  # 返回每一行中最大值元素索引
                train_total += inputs.size(0)
                train_correct += torch.eq(pred, labels).sum().item()
          
            
            # print("=======================test=======================")
            for inputs, labels in test_loader:
                inputs, labels = inputs.to(device), labels.to(device)
                outputs = model(inputs)

                pred = outputs.argmax(dim=1)  # 返回每一行中最大值元素索引
                test_total += inputs.size(0)
                test_correct += torch.eq(pred, labels).sum().item()

            print("train_total = %d, Accuracy = %.5f %%,  test_total= %d, Accuracy = %.5f %%" %(train_total, 100 * train_correct / train_total, test_total, 100 * test_correct / test_total))    

            train_acc_list.append(100 * train_correct / train_total)
            test_acc_list.append(100 * test_correct / test_total)

        # print("Accuracy of the network on the 10000 test images:%.5f %%" % (100 * test_correct / test_total))
        # print("===============================================")

    fig = plt.figure(figsize=(4, 4))
    
    plt.plot(epochs_list, train_acc_list, label='train_acc_list')
    plt.plot(epochs_list, test_acc_list, label='test_acc_list')
    plt.legend()
    plt.title("train_test_acc")
    plt.savefig('GoogLeNet_acc_epoch_{:04d}.png'.format(epochs))
    plt.close()
    
if __name__ == "__main__":
    
    main()

loss和精度acc

torch.Size([64, 10])
PyTorch Version:  1.12.1+cu102
Torchvision Version:  0.13.1+cu102
Load datasets...
Files already downloaded and verified
Files already downloaded and verified
50000 10000
NIN_Net train...
Start Train...
learn_rate:0.010000000000000
epoch = 1/100, batch_num = 782, loss = 1.370396, time = 95.395
train_total = 50000, Accuracy = 63.17600 %,  test_total= 10000, Accuracy = 62.50000 %
learn_rate:0.010000000000000
epoch = 2/100, batch_num = 782, loss = 0.789557, time = 94.268
train_total = 50000, Accuracy = 75.33600 %,  test_total= 10000, Accuracy = 73.89000 %
learn_rate:0.010000000000000
epoch = 3/100, batch_num = 782, loss = 0.581644, time = 95.266
train_total = 50000, Accuracy = 82.81800 %,  test_total= 10000, Accuracy = 79.88000 %
learn_rate:0.010000000000000
epoch = 4/100, batch_num = 782, loss = 0.470994, time = 93.822
train_total = 50000, Accuracy = 84.31000 %,  test_total= 10000, Accuracy = 81.43000 %
learn_rate:0.010000000000000
epoch = 5/100, batch_num = 782, loss = 0.405856, time = 94.878
train_total = 50000, Accuracy = 84.01400 %,  test_total= 10000, Accuracy = 80.49000 %
learn_rate:0.010000000000000
epoch = 6/100, batch_num = 782, loss = 0.357098, time = 94.099
train_total = 50000, Accuracy = 90.65000 %,  test_total= 10000, Accuracy = 86.07000 %
learn_rate:0.010000000000000
epoch = 7/100, batch_num = 782, loss = 0.308426, time = 95.302
train_total = 50000, Accuracy = 86.57200 %,  test_total= 10000, Accuracy = 82.14000 %
learn_rate:0.010000000000000
epoch = 8/100, batch_num = 782, loss = 0.276895, time = 95.147
train_total = 50000, Accuracy = 90.81600 %,  test_total= 10000, Accuracy = 85.88000 %
learn_rate:0.010000000000000
epoch = 9/100, batch_num = 782, loss = 0.244451, time = 95.211
train_total = 50000, Accuracy = 90.74600 %,  test_total= 10000, Accuracy = 84.79000 %
learn_rate:0.010000000000000
epoch = 10/100, batch_num = 782, loss = 0.226096, time = 96.584
train_total = 50000, Accuracy = 93.82000 %,  test_total= 10000, Accuracy = 87.90000 %
learn_rate:0.006000000000000
epoch = 11/100, batch_num = 782, loss = 0.135348, time = 96.430
train_total = 50000, Accuracy = 97.40800 %,  test_total= 10000, Accuracy = 90.50000 %
learn_rate:0.006000000000000
epoch = 12/100, batch_num = 782, loss = 0.105362, time = 95.864
train_total = 50000, Accuracy = 96.17800 %,  test_total= 10000, Accuracy = 89.17000 %
learn_rate:0.006000000000000
epoch = 13/100, batch_num = 782, loss = 0.095123, time = 96.124
train_total = 50000, Accuracy = 96.89200 %,  test_total= 10000, Accuracy = 88.89000 %
learn_rate:0.006000000000000
epoch = 14/100, batch_num = 782, loss = 0.087209, time = 96.014
train_total = 50000, Accuracy = 98.14000 %,  test_total= 10000, Accuracy = 90.53000 %
learn_rate:0.006000000000000
epoch = 15/100, batch_num = 782, loss = 0.080366, time = 95.506
train_total = 50000, Accuracy = 98.32600 %,  test_total= 10000, Accuracy = 90.32000 %
learn_rate:0.006000000000000
epoch = 16/100, batch_num = 782, loss = 0.078542, time = 96.306
train_total = 50000, Accuracy = 97.61600 %,  test_total= 10000, Accuracy = 89.51000 %
learn_rate:0.006000000000000
epoch = 17/100, batch_num = 782, loss = 0.070368, time = 95.010
train_total = 50000, Accuracy = 98.47200 %,  test_total= 10000, Accuracy = 90.23000 %
learn_rate:0.006000000000000
epoch = 18/100, batch_num = 782, loss = 0.073643, time = 96.235
train_total = 50000, Accuracy = 97.79400 %,  test_total= 10000, Accuracy = 89.39000 %
learn_rate:0.006000000000000
epoch = 19/100, batch_num = 782, loss = 0.072382, time = 95.035
train_total = 50000, Accuracy = 98.30000 %,  test_total= 10000, Accuracy = 89.65000 %
learn_rate:0.006000000000000
epoch = 20/100, batch_num = 782, loss = 0.061964, time = 95.757
train_total = 50000, Accuracy = 97.55800 %,  test_total= 10000, Accuracy = 89.25000 %
learn_rate:0.003600000000000
epoch = 21/100, batch_num = 782, loss = 0.031406, time = 95.418
train_total = 50000, Accuracy = 99.81400 %,  test_total= 10000, Accuracy = 92.06000 %
learn_rate:0.003600000000000
epoch = 22/100, batch_num = 782, loss = 0.016657, time = 95.774
train_total = 50000, Accuracy = 99.86000 %,  test_total= 10000, Accuracy = 92.09000 %
learn_rate:0.003600000000000
epoch = 23/100, batch_num = 782, loss = 0.011798, time = 96.257
train_total = 50000, Accuracy = 99.95600 %,  test_total= 10000, Accuracy = 92.47000 %
learn_rate:0.003600000000000
epoch = 24/100, batch_num = 782, loss = 0.008725, time = 96.043
train_total = 50000, Accuracy = 99.97800 %,  test_total= 10000, Accuracy = 92.47000 %
learn_rate:0.003600000000000
epoch = 25/100, batch_num = 782, loss = 0.007397, time = 95.633
train_total = 50000, Accuracy = 99.97800 %,  test_total= 10000, Accuracy = 92.49000 %
learn_rate:0.003600000000000
epoch = 26/100, batch_num = 782, loss = 0.007058, time = 95.648
train_total = 50000, Accuracy = 99.99200 %,  test_total= 10000, Accuracy = 92.58000 %
learn_rate:0.003600000000000
epoch = 27/100, batch_num = 782, loss = 0.005411, time = 96.113
train_total = 50000, Accuracy = 99.99800 %,  test_total= 10000, Accuracy = 92.51000 %
learn_rate:0.003600000000000
epoch = 28/100, batch_num = 782, loss = 0.004637, time = 95.960
train_total = 50000, Accuracy = 99.99800 %,  test_total= 10000, Accuracy = 92.64000 %
learn_rate:0.003600000000000
epoch = 29/100, batch_num = 782, loss = 0.003989, time = 95.811
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 92.70000 %
learn_rate:0.003600000000000
epoch = 30/100, batch_num = 782, loss = 0.003333, time = 96.130
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 92.77000 %
learn_rate:0.002160000000000
epoch = 31/100, batch_num = 782, loss = 0.002816, time = 96.139
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 92.80000 %
learn_rate:0.002160000000000
epoch = 32/100, batch_num = 782, loss = 0.002434, time = 95.981
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 92.91000 %
learn_rate:0.002160000000000
epoch = 33/100, batch_num = 782, loss = 0.002460, time = 95.911
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 92.93000 %
learn_rate:0.002160000000000
epoch = 34/100, batch_num = 782, loss = 0.002303, time = 96.058
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 92.88000 %
learn_rate:0.002160000000000
epoch = 35/100, batch_num = 782, loss = 0.002129, time = 95.845
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 92.84000 %
learn_rate:0.002160000000000
epoch = 36/100, batch_num = 782, loss = 0.002029, time = 96.210
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 92.93000 %
learn_rate:0.002160000000000
epoch = 37/100, batch_num = 782, loss = 0.002060, time = 96.028
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 92.95000 %
learn_rate:0.002160000000000
epoch = 38/100, batch_num = 782, loss = 0.002066, time = 96.241
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 92.90000 %
learn_rate:0.002160000000000
epoch = 39/100, batch_num = 782, loss = 0.002101, time = 95.963
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.04000 %
learn_rate:0.002160000000000
epoch = 40/100, batch_num = 782, loss = 0.002091, time = 95.792
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 92.93000 %
learn_rate:0.001296000000000
epoch = 41/100, batch_num = 782, loss = 0.001967, time = 95.815
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.06000 %
learn_rate:0.001296000000000
epoch = 42/100, batch_num = 782, loss = 0.002068, time = 95.753
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.04000 %
learn_rate:0.001296000000000
epoch = 43/100, batch_num = 782, loss = 0.002134, time = 96.074
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 92.98000 %
learn_rate:0.001296000000000
epoch = 44/100, batch_num = 782, loss = 0.001972, time = 95.305
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.03000 %
learn_rate:0.001296000000000
epoch = 45/100, batch_num = 782, loss = 0.002112, time = 95.660
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.19000 %
learn_rate:0.001296000000000
epoch = 46/100, batch_num = 782, loss = 0.002134, time = 95.843
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.07000 %
learn_rate:0.001296000000000
epoch = 47/100, batch_num = 782, loss = 0.002034, time = 96.097
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.02000 %
learn_rate:0.001296000000000
epoch = 48/100, batch_num = 782, loss = 0.001948, time = 96.196
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.19000 %
learn_rate:0.001296000000000
epoch = 49/100, batch_num = 782, loss = 0.002036, time = 95.903
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.21000 %
learn_rate:0.001296000000000
epoch = 50/100, batch_num = 782, loss = 0.001898, time = 96.279
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.15000 %
learn_rate:0.000777600000000
epoch = 51/100, batch_num = 782, loss = 0.001916, time = 96.313
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.10000 %
learn_rate:0.000777600000000
epoch = 52/100, batch_num = 782, loss = 0.002036, time = 96.318
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.14000 %
learn_rate:0.000777600000000
epoch = 53/100, batch_num = 782, loss = 0.001904, time = 96.007
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.11000 %
learn_rate:0.000777600000000
epoch = 54/100, batch_num = 782, loss = 0.001932, time = 96.268
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.25000 %
learn_rate:0.000777600000000
epoch = 55/100, batch_num = 782, loss = 0.001854, time = 96.555
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.05000 %
learn_rate:0.000777600000000
epoch = 56/100, batch_num = 782, loss = 0.001827, time = 95.625
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.07000 %
learn_rate:0.000777600000000
epoch = 57/100, batch_num = 782, loss = 0.001922, time = 96.120
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.17000 %
learn_rate:0.000777600000000
epoch = 58/100, batch_num = 782, loss = 0.001896, time = 95.852
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.09000 %
learn_rate:0.000777600000000
epoch = 59/100, batch_num = 782, loss = 0.001902, time = 96.587
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.23000 %
learn_rate:0.000777600000000
epoch = 60/100, batch_num = 782, loss = 0.002246, time = 96.677
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.04000 %
learn_rate:0.000466560000000
epoch = 61/100, batch_num = 782, loss = 0.002110, time = 96.461
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.13000 %
learn_rate:0.000466560000000
epoch = 62/100, batch_num = 782, loss = 0.001956, time = 96.045
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.26000 %
learn_rate:0.000466560000000
epoch = 63/100, batch_num = 782, loss = 0.001929, time = 96.355
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.03000 %
learn_rate:0.000466560000000
epoch = 64/100, batch_num = 782, loss = 0.001950, time = 95.994
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.17000 %
learn_rate:0.000466560000000
epoch = 65/100, batch_num = 782, loss = 0.001885, time = 95.865
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.04000 %
learn_rate:0.000466560000000
epoch = 66/100, batch_num = 782, loss = 0.001948, time = 95.952
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.25000 %
learn_rate:0.000466560000000
epoch = 67/100, batch_num = 782, loss = 0.001930, time = 96.614
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.01000 %
learn_rate:0.000466560000000
epoch = 68/100, batch_num = 782, loss = 0.001885, time = 96.163
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.02000 %
learn_rate:0.000466560000000
epoch = 69/100, batch_num = 782, loss = 0.001973, time = 96.255
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.04000 %
learn_rate:0.000466560000000
epoch = 70/100, batch_num = 782, loss = 0.001952, time = 96.205
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.04000 %
learn_rate:0.000279936000000
epoch = 71/100, batch_num = 782, loss = 0.001946, time = 95.993
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.10000 %
learn_rate:0.000279936000000
epoch = 72/100, batch_num = 782, loss = 0.001898, time = 96.283
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.10000 %
learn_rate:0.000279936000000
epoch = 73/100, batch_num = 782, loss = 0.001921, time = 96.161
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.16000 %
learn_rate:0.000279936000000
epoch = 74/100, batch_num = 782, loss = 0.001922, time = 96.465
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.15000 %
learn_rate:0.000279936000000
epoch = 75/100, batch_num = 782, loss = 0.001906, time = 95.855
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.25000 %
learn_rate:0.000279936000000
epoch = 76/100, batch_num = 782, loss = 0.001935, time = 96.168
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.06000 %
learn_rate:0.000279936000000
epoch = 77/100, batch_num = 782, loss = 0.001922, time = 96.120
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.08000 %
learn_rate:0.000279936000000
epoch = 78/100, batch_num = 782, loss = 0.001993, time = 96.087
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.17000 %
learn_rate:0.000279936000000
epoch = 79/100, batch_num = 782, loss = 0.001924, time = 96.356
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.14000 %
learn_rate:0.000279936000000
epoch = 80/100, batch_num = 782, loss = 0.001958, time = 96.420
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.20000 %
learn_rate:0.000167961600000
epoch = 81/100, batch_num = 782, loss = 0.001943, time = 95.762
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.14000 %
learn_rate:0.000167961600000
epoch = 82/100, batch_num = 782, loss = 0.001855, time = 96.882
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.06000 %
learn_rate:0.000167961600000
epoch = 83/100, batch_num = 782, loss = 0.001985, time = 96.236
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 92.95000 %
learn_rate:0.000167961600000
epoch = 84/100, batch_num = 782, loss = 0.002065, time = 96.286
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.04000 %
learn_rate:0.000167961600000
epoch = 85/100, batch_num = 782, loss = 0.001957, time = 96.562
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.02000 %
learn_rate:0.000167961600000
epoch = 86/100, batch_num = 782, loss = 0.001996, time = 96.504
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.05000 %
learn_rate:0.000167961600000
epoch = 87/100, batch_num = 782, loss = 0.001853, time = 96.209
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.22000 %
learn_rate:0.000167961600000
epoch = 88/100, batch_num = 782, loss = 0.001897, time = 95.828
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.11000 %
learn_rate:0.000167961600000
epoch = 89/100, batch_num = 782, loss = 0.002014, time = 96.319
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.29000 %
learn_rate:0.000167961600000
epoch = 90/100, batch_num = 782, loss = 0.001906, time = 95.519
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.14000 %
learn_rate:0.000100776960000
epoch = 91/100, batch_num = 782, loss = 0.001962, time = 95.681
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.16000 %
learn_rate:0.000100776960000
epoch = 92/100, batch_num = 782, loss = 0.001853, time = 96.188
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.15000 %
learn_rate:0.000100776960000
epoch = 93/100, batch_num = 782, loss = 0.001917, time = 96.333
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.03000 %
learn_rate:0.000100776960000
epoch = 94/100, batch_num = 782, loss = 0.001926, time = 95.970
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.12000 %
learn_rate:0.000100776960000
epoch = 95/100, batch_num = 782, loss = 0.002016, time = 96.025
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.04000 %
learn_rate:0.000100776960000
epoch = 96/100, batch_num = 782, loss = 0.001895, time = 95.694
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.17000 %
learn_rate:0.000100776960000
epoch = 97/100, batch_num = 782, loss = 0.001929, time = 95.846
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.29000 %
learn_rate:0.000100776960000
epoch = 98/100, batch_num = 782, loss = 0.001896, time = 95.482
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.09000 %
learn_rate:0.000100776960000
epoch = 99/100, batch_num = 782, loss = 0.001956, time = 96.497
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.07000 %
learn_rate:0.000100776960000
epoch = 100/100, batch_num = 782, loss = 0.001868, time = 95.987
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 93.00000 %

 

 图 GoogLenet_acc_epoch_100