10-shuffleNet 图像分类

 

 

shuffleNet的pytoch实现：

import torch.nn as nn
import torch
import torch.nn.functional as F
from collections import OrderedDict
# from torchsummary import summary
 
 
def _make_divisible(ch, divisor=8, min_ch=None):
    """
    This function is taken from the original tf repo.
    It ensures that all layers have a channel number that is divisible by 8
    It can be seen here:
    https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
    """
    if min_ch is None:
        min_ch = divisor
    new_ch = max(min_ch, int(ch + divisor / 2) // divisor * divisor)
    # Make sure that round down does not go down by more than 10%.
    if new_ch < 0.9 * ch:
        new_ch += divisor
    return new_ch
 
#基本的卷积BNrelu
class baseConv(nn.Module):
    def __init__(self,inchannels,outchannels,kernel_size,stride,groups,hasRelu=False):
        super(baseConv, self).__init__()
        if hasRelu:
            #判断是否有relu激活函数
            activate=nn.ReLU
        else:
            activate=nn.Identity
        pad=kernel_size//2
        self.baseconv=nn.Sequential(
            nn.Conv2d(in_channels=inchannels,out_channels=outchannels,kernel_size=kernel_size,stride=stride,padding=pad,groups=groups,bias=False),
            nn.BatchNorm2d(outchannels),
            activate()
        )
 
    def forward(self,x):
        out=self.baseconv(x)
        return out
 
 
#通道重排
def ChannelShuffle(x,groups):
    batch_size,channel,height,width=x.size()
    #获得每组的组内channel
    inner_channel=channel//groups
    #[batch,groups,inner_channel,height,width]
    x=x.view(batch_size,groups,inner_channel,height,width)
    x=torch.transpose(x,1,2).contiguous()
    x=x.view(batch_size,-1,height,width)
    return x
 
 
#stage结构
class Residual(nn.Module):
    def __init__(self,inchannels,outchannels,stride,groups):
        super(Residual, self).__init__()
        self.add_=True      #shortcut为相加操作
        self.groups=groups
 
        hidden_channel=inchannels//4
        #当输入channel不等于24时候才有第一个1*1conv
        self.has_conv1=True
        if inchannels!=24:
            self.channel1_first1=baseConv(inchannels=inchannels,outchannels=hidden_channel,kernel_size=1,stride=1,groups=groups,hasRelu=True)
        else:
            self.has_conv1=False
            self.channel1_first1=nn.Identity()
            hidden_channel=inchannels
 
        #channel1
        self.channel1=nn.Sequential(
            baseConv(inchannels=hidden_channel,outchannels=hidden_channel,kernel_size=3,stride=stride,groups=hidden_channel),
            baseConv(inchannels=hidden_channel,outchannels=outchannels,kernel_size=1,stride=1,groups=groups)
        )
 
        #channel2
        if stride==2:
            self.channel2=nn.AvgPool2d(kernel_size=3,stride=stride,padding=1)
            self.add_=False
 
 
    def forward(self,x):
        if self.has_conv1:
            x1=self.channel1_first1(x)
            x1=ChannelShuffle(x1,groups=self.groups)
            out=self.channel1(x1)
        else:
            out=self.channel1(x)
        if self.add_:
            out+=x
            return F.relu_(out)
        else:
            out2=self.channel2(x)
            out=torch.cat((out,out2),dim=1)
            return F.relu_(out)
 
 
#shuffleNet
class ShuffleNet(nn.Module):
    def __init__(self,groups,out_channel_list,num_classes,rate,init_weight=True):
        super(ShuffleNet, self).__init__()
 
        #定义有序字典存放网络结构
        self.Module_List=OrderedDict()
 
        self.Module_List.update({'Conv1':nn.Sequential(nn.Conv2d(3,_make_divisible(24*rate,divisor=4*groups),3,2,1,bias=False),nn.BatchNorm2d(_make_divisible(24*rate,4*groups)),nn.ReLU())})
        self.Module_List.update({'MaxPool1':nn.MaxPool2d(3,2,1)})
 
        #net_config [inchannels,outchannels,stride]
        net_config=[[out_channel_list[0],out_channel_list[0],1],
                    [out_channel_list[0],out_channel_list[1],2],
                    [out_channel_list[1],out_channel_list[2],1],
                    [out_channel_list[2],out_channel_list[3],2],
                    [out_channel_list[3],out_channel_list[4],1]]
        repeat_num=[3,1,7,1,3]
 
        #搭建stage部分
        self.Module_List.update({'stage0_0':Residual(_make_divisible(24*rate,4*groups),_make_divisible((out_channel_list[0]-_make_divisible(24*rate,4*groups))*rate,4*groups),stride=2,groups=groups)})
        for idx,item in enumerate(repeat_num):
            config_item=net_config[idx]
            for j in range(item):
                if j==0 and idx!=0 and config_item[-1]==2:
                    self.Module_List.update({'stage{}_{}'.format(idx,j+1):Residual(_make_divisible(config_item[0]*rate,4*groups),_make_divisible((config_item[1]-config_item[0])*rate,4*groups),config_item[2],groups)})
                else:
                    self.Module_List.update({'stage{}_{}'.format(idx,j+1):Residual(_make_divisible(config_item[0]*rate,4*groups),_make_divisible(config_item[1]*rate,4*groups),config_item[2],groups)})
                config_item[-1]=1       #重复stage的stride=1
                config_item[0]=config_item[1]
 
        self.Module_List.update({'GlobalPool':nn.AvgPool2d(kernel_size=7,stride=1)})
 
        self.Module_List=nn.Sequential(self.Module_List)
 
        self.linear=nn.Sequential(
            nn.Dropout(p=0.2),
            nn.Linear(_make_divisible(out_channel_list[-1]*rate,4*groups),num_classes)
        )
 
        if init_weight:
            self.init_weight()
    def forward(self,x):
        out=self.Module_List(x)
        out=out.view(out.size(0),-1)
        out=self.linear(out)
        return out
 
    def init_weight(self):
        for w in self.modules():
            if isinstance(w, nn.Conv2d):
                nn.init.kaiming_normal_(w.weight, mode='fan_out')
                if w.bias is not None:
                    nn.init.zeros_(w.bias)
            elif isinstance(w, nn.BatchNorm2d):
                nn.init.ones_(w.weight)
                nn.init.zeros_(w.bias)
            elif isinstance(w, nn.Linear):
                nn.init.normal_(w.weight, 0, 0.01)
                nn.init.zeros_(w.bias)
 
#定义shufflenet_
def shuffleNet_g1_(num_classes=10,rate=1.0):
    config=[144,288,288,576,576]
    return ShuffleNet(groups=1,out_channel_list=config,num_classes=num_classes,rate=rate)
 
def shuffleNet_g2_(num_classes=10,rate=1.0):       #
    config=[200,400,400,800,800]
    return ShuffleNet(groups=2,out_channel_list=config,num_classes=num_classes,rate=rate)
 
def shuffleNet_g3_(num_classes=10,rate=1.0):
    config=[240,480,480,960,960]
    return ShuffleNet(groups=3,out_channel_list=config,num_classes=num_classes,rate=rate)
 
def shuffleNet_g4_(num_classes=10,rate=1.0):
    config=[272,544,544,1088,1088]
    return ShuffleNet(groups=4,out_channel_list=config,num_classes=num_classes,rate=rate)
 
def shuffleNet_g8_(num_classes=10,rate=1.0):
    config=[384,768,768,1536,1536]
    return ShuffleNet(groups=8,out_channel_list=config,num_classes=num_classes,rate=rate)
 
# if __name__ == '__main__':
#     net=shuffleNet_g3_(10,rate=1.0).to('cuda')
#     print(net)
#     summary(net,(3,224,224))

classfyNet_train.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
from MobileNet_v3 import mobilenet_v3
from shuffleNet import shuffleNet_g3_

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 = mobilenet_v3().to(device)
    model = shuffleNet_g3_().to(device)
    # model = AlexNet(num_classes=10, init_weights=True).to(device)
    print(" shuffleNet_g3_ 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('shuffleNet_g3_acc_epoch_{:04d}.png'.format(epochs))
    plt.close()
    
if __name__ == "__main__":
    
    main()

loss 和acc

(pytorch-CycleGAN-and-pix2pix) python classfyNet_train.py
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
 shuffleNet_g3_ train...
Start Train...
learn_rate:0.010000000000000
epoch = 1/100, batch_num = 782, loss = 2.462858, time = 64.375
train_total = 50000, Accuracy = 56.65400 %,  test_total= 10000, Accuracy = 55.78000 %
learn_rate:0.010000000000000
epoch = 2/100, batch_num = 782, loss = 1.160206, time = 63.712
train_total = 50000, Accuracy = 65.57400 %,  test_total= 10000, Accuracy = 63.73000 %
learn_rate:0.010000000000000
epoch = 3/100, batch_num = 782, loss = 0.939427, time = 63.848
train_total = 50000, Accuracy = 70.27200 %,  test_total= 10000, Accuracy = 67.48000 %
learn_rate:0.010000000000000
epoch = 4/100, batch_num = 782, loss = 0.829697, time = 64.088
train_total = 50000, Accuracy = 73.54000 %,  test_total= 10000, Accuracy = 71.55000 %
learn_rate:0.010000000000000
epoch = 5/100, batch_num = 782, loss = 0.705321, time = 63.891
train_total = 50000, Accuracy = 77.58000 %,  test_total= 10000, Accuracy = 75.42000 %
learn_rate:0.010000000000000
epoch = 6/100, batch_num = 782, loss = 0.615606, time = 63.788
train_total = 50000, Accuracy = 81.87800 %,  test_total= 10000, Accuracy = 78.72000 %
learn_rate:0.010000000000000
epoch = 7/100, batch_num = 782, loss = 0.558104, time = 64.142
train_total = 50000, Accuracy = 83.93200 %,  test_total= 10000, Accuracy = 80.47000 %
learn_rate:0.010000000000000
epoch = 8/100, batch_num = 782, loss = 0.506482, time = 64.006
train_total = 50000, Accuracy = 86.27000 %,  test_total= 10000, Accuracy = 82.37000 %
learn_rate:0.010000000000000
epoch = 9/100, batch_num = 782, loss = 0.465115, time = 63.775
train_total = 50000, Accuracy = 86.68000 %,  test_total= 10000, Accuracy = 82.64000 %
learn_rate:0.010000000000000
epoch = 10/100, batch_num = 782, loss = 0.431530, time = 63.784
train_total = 50000, Accuracy = 86.92400 %,  test_total= 10000, Accuracy = 82.38000 %
learn_rate:0.006000000000000
epoch = 11/100, batch_num = 782, loss = 0.344329, time = 64.106
train_total = 50000, Accuracy = 91.15600 %,  test_total= 10000, Accuracy = 85.26000 %
learn_rate:0.006000000000000
epoch = 12/100, batch_num = 782, loss = 0.321713, time = 64.323
train_total = 50000, Accuracy = 91.30200 %,  test_total= 10000, Accuracy = 84.90000 %
learn_rate:0.006000000000000
epoch = 13/100, batch_num = 782, loss = 0.299179, time = 63.639
train_total = 50000, Accuracy = 91.61200 %,  test_total= 10000, Accuracy = 84.90000 %
learn_rate:0.006000000000000
epoch = 14/100, batch_num = 782, loss = 0.282726, time = 63.733
train_total = 50000, Accuracy = 92.61600 %,  test_total= 10000, Accuracy = 85.92000 %
learn_rate:0.006000000000000
epoch = 15/100, batch_num = 782, loss = 0.269207, time = 63.728
train_total = 50000, Accuracy = 93.07800 %,  test_total= 10000, Accuracy = 85.78000 %
learn_rate:0.006000000000000
epoch = 16/100, batch_num = 782, loss = 0.258053, time = 63.725
train_total = 50000, Accuracy = 93.90600 %,  test_total= 10000, Accuracy = 86.29000 %
learn_rate:0.006000000000000
epoch = 17/100, batch_num = 782, loss = 0.247075, time = 63.684
train_total = 50000, Accuracy = 92.80400 %,  test_total= 10000, Accuracy = 85.27000 %
learn_rate:0.006000000000000
epoch = 18/100, batch_num = 782, loss = 0.238726, time = 63.705
train_total = 50000, Accuracy = 93.13800 %,  test_total= 10000, Accuracy = 85.25000 %
learn_rate:0.006000000000000
epoch = 19/100, batch_num = 782, loss = 0.220595, time = 63.783
train_total = 50000, Accuracy = 93.76400 %,  test_total= 10000, Accuracy = 85.60000 %
learn_rate:0.006000000000000
epoch = 20/100, batch_num = 782, loss = 0.218569, time = 63.865
train_total = 50000, Accuracy = 93.74800 %,  test_total= 10000, Accuracy = 85.93000 %
learn_rate:0.003600000000000
epoch = 21/100, batch_num = 782, loss = 0.149462, time = 63.736
train_total = 50000, Accuracy = 97.29800 %,  test_total= 10000, Accuracy = 87.88000 %
learn_rate:0.003600000000000
epoch = 22/100, batch_num = 782, loss = 0.119382, time = 63.730
train_total = 50000, Accuracy = 97.49400 %,  test_total= 10000, Accuracy = 87.68000 %
learn_rate:0.003600000000000
epoch = 23/100, batch_num = 782, loss = 0.109001, time = 64.248
train_total = 50000, Accuracy = 97.75200 %,  test_total= 10000, Accuracy = 87.76000 %
learn_rate:0.003600000000000
epoch = 24/100, batch_num = 782, loss = 0.109486, time = 64.147
train_total = 50000, Accuracy = 97.35000 %,  test_total= 10000, Accuracy = 86.76000 %
learn_rate:0.003600000000000
epoch = 25/100, batch_num = 782, loss = 0.109683, time = 63.822
train_total = 50000, Accuracy = 98.13000 %,  test_total= 10000, Accuracy = 87.84000 %
learn_rate:0.003600000000000
epoch = 26/100, batch_num = 782, loss = 0.098647, time = 63.886
train_total = 50000, Accuracy = 98.16800 %,  test_total= 10000, Accuracy = 87.58000 %
learn_rate:0.003600000000000
epoch = 27/100, batch_num = 782, loss = 0.101305, time = 63.814
train_total = 50000, Accuracy = 97.82600 %,  test_total= 10000, Accuracy = 87.36000 %
learn_rate:0.003600000000000
epoch = 28/100, batch_num = 782, loss = 0.099845, time = 63.648
train_total = 50000, Accuracy = 98.02600 %,  test_total= 10000, Accuracy = 87.77000 %
learn_rate:0.003600000000000
epoch = 29/100, batch_num = 782, loss = 0.091574, time = 63.675
train_total = 50000, Accuracy = 98.26000 %,  test_total= 10000, Accuracy = 87.52000 %
learn_rate:0.003600000000000
epoch = 30/100, batch_num = 782, loss = 0.091463, time = 64.017
train_total = 50000, Accuracy = 98.21800 %,  test_total= 10000, Accuracy = 86.83000 %
learn_rate:0.002160000000000
epoch = 31/100, batch_num = 782, loss = 0.057245, time = 63.766
train_total = 50000, Accuracy = 99.53600 %,  test_total= 10000, Accuracy = 88.44000 %
learn_rate:0.002160000000000
epoch = 32/100, batch_num = 782, loss = 0.039178, time = 63.689
train_total = 50000, Accuracy = 99.72000 %,  test_total= 10000, Accuracy = 88.72000 %
learn_rate:0.002160000000000
epoch = 33/100, batch_num = 782, loss = 0.030545, time = 63.836
train_total = 50000, Accuracy = 99.83000 %,  test_total= 10000, Accuracy = 88.49000 %
learn_rate:0.002160000000000
epoch = 34/100, batch_num = 782, loss = 0.026627, time = 63.690
train_total = 50000, Accuracy = 99.83200 %,  test_total= 10000, Accuracy = 88.66000 %
learn_rate:0.002160000000000
epoch = 35/100, batch_num = 782, loss = 0.024787, time = 63.707
train_total = 50000, Accuracy = 99.88600 %,  test_total= 10000, Accuracy = 88.74000 %
learn_rate:0.002160000000000
epoch = 36/100, batch_num = 782, loss = 0.021373, time = 63.808
train_total = 50000, Accuracy = 99.92400 %,  test_total= 10000, Accuracy = 88.69000 %
learn_rate:0.002160000000000
epoch = 37/100, batch_num = 782, loss = 0.022256, time = 63.757
train_total = 50000, Accuracy = 99.93200 %,  test_total= 10000, Accuracy = 88.60000 %
learn_rate:0.002160000000000
epoch = 38/100, batch_num = 782, loss = 0.019585, time = 64.066
train_total = 50000, Accuracy = 99.85400 %,  test_total= 10000, Accuracy = 88.53000 %
learn_rate:0.002160000000000
epoch = 39/100, batch_num = 782, loss = 0.018379, time = 63.657
train_total = 50000, Accuracy = 99.89000 %,  test_total= 10000, Accuracy = 88.72000 %
learn_rate:0.002160000000000
epoch = 40/100, batch_num = 782, loss = 0.021633, time = 63.823
train_total = 50000, Accuracy = 99.93200 %,  test_total= 10000, Accuracy = 88.59000 %
learn_rate:0.001296000000000
epoch = 41/100, batch_num = 782, loss = 0.013789, time = 64.312
train_total = 50000, Accuracy = 99.99400 %,  test_total= 10000, Accuracy = 89.13000 %
learn_rate:0.001296000000000
epoch = 42/100, batch_num = 782, loss = 0.010126, time = 63.708
train_total = 50000, Accuracy = 99.99200 %,  test_total= 10000, Accuracy = 89.23000 %
learn_rate:0.001296000000000
epoch = 43/100, batch_num = 782, loss = 0.009423, time = 63.673
train_total = 50000, Accuracy = 99.99000 %,  test_total= 10000, Accuracy = 89.28000 %
learn_rate:0.001296000000000
epoch = 44/100, batch_num = 782, loss = 0.007520, time = 63.867
train_total = 50000, Accuracy = 99.99600 %,  test_total= 10000, Accuracy = 89.22000 %
learn_rate:0.001296000000000
epoch = 45/100, batch_num = 782, loss = 0.008270, time = 63.773
train_total = 50000, Accuracy = 99.99400 %,  test_total= 10000, Accuracy = 89.32000 %
learn_rate:0.001296000000000
epoch = 46/100, batch_num = 782, loss = 0.008582, time = 63.805
train_total = 50000, Accuracy = 99.99800 %,  test_total= 10000, Accuracy = 89.30000 %
learn_rate:0.001296000000000
epoch = 47/100, batch_num = 782, loss = 0.006985, time = 63.897
train_total = 50000, Accuracy = 99.99600 %,  test_total= 10000, Accuracy = 89.15000 %
learn_rate:0.001296000000000
epoch = 48/100, batch_num = 782, loss = 0.007605, time = 63.940
train_total = 50000, Accuracy = 99.99800 %,  test_total= 10000, Accuracy = 89.28000 %
learn_rate:0.001296000000000
epoch = 49/100, batch_num = 782, loss = 0.005922, time = 64.020
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.11000 %
learn_rate:0.001296000000000
epoch = 50/100, batch_num = 782, loss = 0.005957, time = 63.700
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.16000 %
learn_rate:0.000777600000000
epoch = 51/100, batch_num = 782, loss = 0.005145, time = 63.793
train_total = 50000, Accuracy = 99.99800 %,  test_total= 10000, Accuracy = 89.23000 %
learn_rate:0.000777600000000
epoch = 52/100, batch_num = 782, loss = 0.005367, time = 63.921
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.28000 %
learn_rate:0.000777600000000
epoch = 53/100, batch_num = 782, loss = 0.005168, time = 64.264
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.28000 %
learn_rate:0.000777600000000
epoch = 54/100, batch_num = 782, loss = 0.005301, time = 64.002
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.19000 %
learn_rate:0.000777600000000
epoch = 55/100, batch_num = 782, loss = 0.004463, time = 63.766
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.18000 %
learn_rate:0.000777600000000
epoch = 56/100, batch_num = 782, loss = 0.004110, time = 63.826
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.29000 %
learn_rate:0.000777600000000
epoch = 57/100, batch_num = 782, loss = 0.004242, time = 63.747
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.27000 %
learn_rate:0.000777600000000
epoch = 58/100, batch_num = 782, loss = 0.004406, time = 63.867
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.23000 %
learn_rate:0.000777600000000
epoch = 59/100, batch_num = 782, loss = 0.004135, time = 63.828
train_total = 50000, Accuracy = 99.99800 %,  test_total= 10000, Accuracy = 89.34000 %
learn_rate:0.000777600000000
epoch = 60/100, batch_num = 782, loss = 0.004014, time = 63.833
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.37000 %
learn_rate:0.000466560000000
epoch = 61/100, batch_num = 782, loss = 0.003722, time = 63.610
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.45000 %
learn_rate:0.000466560000000
epoch = 62/100, batch_num = 782, loss = 0.003552, time = 63.660
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.36000 %
learn_rate:0.000466560000000
epoch = 63/100, batch_num = 782, loss = 0.003629, time = 64.358
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.33000 %
learn_rate:0.000466560000000
epoch = 64/100, batch_num = 782, loss = 0.003581, time = 63.670
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.44000 %
learn_rate:0.000466560000000
epoch = 65/100, batch_num = 782, loss = 0.003261, time = 64.103
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.29000 %
learn_rate:0.000466560000000
epoch = 66/100, batch_num = 782, loss = 0.003679, time = 63.685
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.31000 %
learn_rate:0.000466560000000
epoch = 67/100, batch_num = 782, loss = 0.003586, time = 64.044
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.17000 %
learn_rate:0.000466560000000
epoch = 68/100, batch_num = 782, loss = 0.003351, time = 64.318
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.52000 %
learn_rate:0.000466560000000
epoch = 69/100, batch_num = 782, loss = 0.003492, time = 63.885
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.40000 %
learn_rate:0.000466560000000
epoch = 70/100, batch_num = 782, loss = 0.003522, time = 63.692
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.27000 %
learn_rate:0.000279936000000
epoch = 71/100, batch_num = 782, loss = 0.003545, time = 64.041
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.27000 %
learn_rate:0.000279936000000
epoch = 72/100, batch_num = 782, loss = 0.003211, time = 64.332
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.40000 %
learn_rate:0.000279936000000
epoch = 73/100, batch_num = 782, loss = 0.003316, time = 63.811
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.44000 %
learn_rate:0.000279936000000
epoch = 74/100, batch_num = 782, loss = 0.003299, time = 64.060
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.45000 %
learn_rate:0.000279936000000
epoch = 75/100, batch_num = 782, loss = 0.003383, time = 63.998
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.33000 %
learn_rate:0.000279936000000
epoch = 76/100, batch_num = 782, loss = 0.003282, time = 63.747
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.29000 %
learn_rate:0.000279936000000
epoch = 77/100, batch_num = 782, loss = 0.002967, time = 63.960
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.18000 %
learn_rate:0.000279936000000
epoch = 78/100, batch_num = 782, loss = 0.003005, time = 63.686
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.34000 %
learn_rate:0.000279936000000
epoch = 79/100, batch_num = 782, loss = 0.003053, time = 63.720
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.32000 %
learn_rate:0.000279936000000
epoch = 80/100, batch_num = 782, loss = 0.003222, time = 63.766
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.42000 %
learn_rate:0.000167961600000
epoch = 81/100, batch_num = 782, loss = 0.002952, time = 63.796
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.21000 %
learn_rate:0.000167961600000
epoch = 82/100, batch_num = 782, loss = 0.003042, time = 63.742
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.34000 %
learn_rate:0.000167961600000
epoch = 83/100, batch_num = 782, loss = 0.003519, time = 63.730
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.33000 %
learn_rate:0.000167961600000
epoch = 84/100, batch_num = 782, loss = 0.003047, time = 64.059
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.25000 %
learn_rate:0.000167961600000
epoch = 85/100, batch_num = 782, loss = 0.002967, time = 63.633
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.51000 %
learn_rate:0.000167961600000
epoch = 86/100, batch_num = 782, loss = 0.002872, time = 64.210
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.56000 %
learn_rate:0.000167961600000
epoch = 87/100, batch_num = 782, loss = 0.003119, time = 64.020
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.21000 %
learn_rate:0.000167961600000
epoch = 88/100, batch_num = 782, loss = 0.002836, time = 64.013
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.36000 %
learn_rate:0.000167961600000
epoch = 89/100, batch_num = 782, loss = 0.002810, time = 64.153
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.26000 %
learn_rate:0.000167961600000
epoch = 90/100, batch_num = 782, loss = 0.002952, time = 64.026
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.29000 %
learn_rate:0.000100776960000
epoch = 91/100, batch_num = 782, loss = 0.002950, time = 63.881
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.35000 %
learn_rate:0.000100776960000
epoch = 92/100, batch_num = 782, loss = 0.002839, time = 65.006
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.40000 %
learn_rate:0.000100776960000
epoch = 93/100, batch_num = 782, loss = 0.002889, time = 65.473
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.34000 %
learn_rate:0.000100776960000
epoch = 94/100, batch_num = 782, loss = 0.002764, time = 64.265
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.30000 %
learn_rate:0.000100776960000
epoch = 95/100, batch_num = 782, loss = 0.003014, time = 63.756
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.25000 %
learn_rate:0.000100776960000
epoch = 96/100, batch_num = 782, loss = 0.002896, time = 63.826
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.26000 %
learn_rate:0.000100776960000
epoch = 97/100, batch_num = 782, loss = 0.002860, time = 63.741
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.39000 %
learn_rate:0.000100776960000
epoch = 98/100, batch_num = 782, loss = 0.002967, time = 63.768
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.31000 %
learn_rate:0.000100776960000
epoch = 99/100, batch_num = 782, loss = 0.002842, time = 63.707
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.30000 %
learn_rate:0.000100776960000
epoch = 100/100, batch_num = 782, loss = 0.002862, time = 63.831
train_total = 50000, Accuracy = 100.00000 %,  test_total= 10000, Accuracy = 89.45000 %

 

图shuffleNet_g3_acc_epoch_100