• 周二. 9月 27th, 2022

5G编程聚合网

5G时代下一个聚合的编程学习网

热门标签

人脸识别智能小程序 | Tensorflow挑战Cifar-10图像分类任务 | 04

admin

11月 28, 2021

TF挑战cifar10

cifar100有两类标签,一个是大类标签,一个是小类标签,也就是一个是粗粒度标签,一个是细粒度标签,

上面的代码是解析cifar10的,前面已经讲解过,这里不再赘述。

使用 tf.train.string_input_producer 的方式来对打包好的TFRecord文件进行读取。

将所有的训练样本存放在 train.tfrecord,将所有的测试样本存放在 test.tfrecord。

TF训练框架搭建:

  • Data

首先是数据的读取和数据的打包。

  • Net

网络的搭建,这里采用slim来搭建网络结构,因为slim是对tf更加高层的封装,可以写更加简洁的代码。

  • Loss

Loss本身就是网络的一部分,这个会采用softmaxLoss来进行Loss定义。

另外还会定义正则化的Loss。

  • Summary

Summary完成了训练过程中日志的记录。

  • Session

Session完成了构造出网络结构后,如果对计算图中的结点进行计算,会通过Session在后端完成整个网络的BP。并通过Feed给网络数据,Fetch获得输出的张量。

训练代码,也就是baseline版本,要如何进行优化呢?上面提供了几个参考思路。

  • 更多的数据增强策略,比如:mixup等

通过数据增强的策略,来丰富样本量,进而提高模型对更多样本的泛化能力。

  • 更好的主干网络,比如:SENet等

有VGG,ResNet这样的主干网络,当然,SENet比ResNet的性能更好,可以实验哪个主干网络实验出来的效果更好。

  • 更好的标签策略,比如:Soft-label策略

cifar10的标签就是从0到9十个标签,这里可以采用soft-label的策略,比如有些物体既像飞机又像汽车,那么就可以采用软的策略,来对标签进行预处理。

  • 更好的loss设计,比如:采用分类+回归smooth-l1 loss等

另外可以采用更好的loss,这里采用交叉熵损失来完成图像分类的任务,另外大家也可以考虑结合回归的loss,来进行一个多个loss的约束。

  • 不同的优化器、参数初始化方法等

Cifar10数据读取与数据增强

文件项目的目录结构如上图

  • data: 存放数据 这里是打包好的TFRecord
  • logdirs:存放log日志信息
  • model:存放训练好的模型

readcifar10.py

import tensorflow as tf


def read(batchsize=64, type=1, no_aug_data=1):
    """
    读取TFRecord的脚本

    params
    batchsize:批大小 默认64
    type: test or train 表示从test中读数据还是从train中读数据 0表示train 1表示test
    no_aug_data: 是否进行数据增强 1 or 0
    """
    reader = tf.TFRecordReader()
    """
    搭建模型的时候每训练一定的次数,或每训练一个epoch的时候,这时候会从test文件进行一次测试
    """
    if type == 0:  # train
        file_list = ["data/train.tfrecord"]
    if type == 1:  # test
        file_list = ["data/test.tfrecord"]

    filename_queue = tf.train.string_input_producer(
        file_list, num_epochs=None, shuffle=True
    )
    _, serialized_example = reader.read(filename_queue)

    batch = tf.train.shuffle_batch([serialized_example], batchsize, capacity=batchsize * 10,
                                   min_after_dequeue=batchsize * 5)

    #
    feature = {'image': tf.FixedLenFeature([], tf.string),
               'label': tf.FixedLenFeature([], tf.int64)}

    features = tf.parse_example(batch, features=feature)

    images = features["image"]

    img_batch = tf.decode_raw(images, tf.uint8)
    img_batch = tf.cast(img_batch, tf.float32)
    img_batch = tf.reshape(img_batch, [batchsize, 32, 32, 3])

    """
    这里对train的数据进行数据增强 
    数据增强只对train数据
    """
    if type == 0 and no_aug_data == 1:
        # 随机裁剪
        distorted_image = tf.random_crop(img_batch,
                                         [batchsize, 28, 28, 3])
        # 随机对比度
        distorted_image = tf.image.random_contrast(distorted_image,
                                                   lower=0.8,
                                                   upper=1.2)
        # 随机色调
        distorted_image = tf.image.random_hue(distorted_image,
                                              max_delta=0.2)
        # 随机饱和度
        distorted_image = tf.image.random_saturation(distorted_image,
                                                     lower=0.8,
                                                     upper=1.2)
        # 对处理过的图像进行取值范围的约束
        img_batch = tf.clip_by_value(distorted_image, 0, 255)

    # 最后将图像resize回[32,32]
    img_batch = tf.image.resize_images(img_batch, [32, 32])
    label_batch = tf.cast(features['label'], tf.int64)

    # [-1,1] 将图片归一化
    img_batch = tf.cast(img_batch, tf.float32) / 128.0 - 1.0
    
    return img_batch, label_batch

TensorFlow+Slim网络结构搭建

def model(image, keep_prob=0.8, is_training=True):
    """
    在model中我们会定义网络结构
    params
    image: 输入的图片

    return 概率分布值 10 dim vector
    """

    # batchnorm的参数
    batch_norm_params = {
        "is_training": is_training,  # train:True test:False
        "epsilon": 1e-5,  # 这个值是防止batchnorm在归一化的时候除0
        "decay": 0.997,  # 衰减系数
        'scale': True,
        'updates_collections': tf.GraphKeys.UPDATE_OPS
    }

    """
    定义优化器
    用 slim.arg_scope()为目标函数设置默认参数.
    下面两个with,完成卷积默认参数的初始化和pooling层默认参数的初始化
    一个with就是一个参数域 网络可以使用通过的参数
    """
    with slim.arg_scope(
        [slim.conv2d],  # 这里是给 slim.conv2d 规定过了后面的参数
        weights_initializer=slim.variance_scaling_initializer(),  # 方差尺度不变来进行初始化
        activation_fn=tf.nn.relu,  # 默认激活函数为relu 在卷积之后加入激活函数
        weights_regularizer=slim.l2_regularizer(
            0.0001),  # 权值的正则化约束 正则项权值为0.0001
        normalizer_fn=slim.batch_norm,  # 在卷积机后加入 BatchNorm
            normalizer_params=batch_norm_params):

        with slim.arg_scope([slim.max_pool2d], padding="SAME"):  # 给 slim.max_pool2d 规定参数
            """
            接下来利用卷积层、池化层、全连接层搭建一个cifar10用于图像分类的全连接网
            """
            # 输入image 学习32个卷积核(channel) 卷积核大小 [3,3] 卷积层命名 conv1
            net = slim.conv2d(image, 32, [3, 3], scope='conv1')
            # 输入net 学习32个卷积核 卷积核大小 [3,3] 卷积层命名 conv2
            net = slim.conv2d(net, 32, [3, 3], scope='conv2')
            # 输入net 池化核大小[3,3] stride=2(进行两倍下采样)
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool1')
            """
            ===========
            上面 conv+conv+maxpool 算是一个基本单元,后面基本就是使用这样的基本单元进行堆叠
            ==========
            """
            # 每次经过pooling之后 卷积层channel的数量应该翻倍
            net = slim.conv2d(net, 64, [3, 3], scope='conv3')
            net = slim.conv2d(net, 64, [3, 3], scope='conv4')
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool2')
            net = slim.conv2d(net, 128, [3, 3], scope='conv5')
            net = slim.conv2d(net, 128, [3, 3], scope='conv6')
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool3')
            # 经过8倍下采样之后 在加入一个卷积层
            net = slim.conv2d(net, 256, [3, 3], scope='conv7')
            """
            特征图维度 (n,h,w,c)
            对 h,w 进行均值的求解 得到 (n,1,1,c) 因为 reduce_mean 就是降维求平均
            """
            net = tf.reduce_mean(net, axis=[1, 2])  # nhwc--n11c
            """
            slim.flatten 将输入扁平化但保留batch_size,假设第一维是batch。
            将 (n,1,1,c) 转为 (n,c)
            """
            net = slim.flatten(net)
            # 全连接层 这里还不着急分类 (1,1024)可以作为从图像中提取出来的特征
            net = slim.fully_connected(net, 1024)
            """
            全连接层的参数太多 要加入dropout层 来进行正则化
            keep_prob 概率值 定义了我们对当前神经元选择的概率
            在训练和测试的时候,这个概率要取不同的值 训练的时候要取<1 测试的时候要=1
            """
            slim.dropout(net, keep_prob)
            # 输出为10 对应了10个分类类别
            net = slim.fully_connected(net, 10)
    return net  # 10 dim vec

这里的模型设计基本是沿用了VGG的设计思路,采用了(3*3)的小卷积核,每次pooling后对channel的数量进行翻倍,并且在全连接层后面加入了dropout层。另外在经过8倍下采样后采用了一个average pooling层,进行一个全图的池化,最后输出一个10维的概率分布值。

Loss、Optimal、Learning Rate、BN等定义

Loss层定义

def loss(logits, label):
    """
    loss使用交叉熵损失函数
    param
    logits: 预测出来的概率分布值
    label: 实际的label

    return 分类的loss
    """
    # 对label进行one-hot编码 定义one-hot长度为10
    one_hot_label = slim.one_hot_encoding(label, 10) 
    # 使用交叉熵损失函数 并传入 预测值 和 one-hot label
    slim.losses.softmax_cross_entropy(logits, one_hot_label)

    """
    在前面 slim.arg_scope 中定义了weights_regularizer=slim.l2_regularizer(0.0001)
    通过 tf.GraphKeys.REGULARIZATION_LOSSES 可以拿到这些loss正则化的集合
    """
    reg_set = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
    # 将这些正则化loss进行相加 计算出总体的l2_loss
    l2_loss = tf.add_n(reg_set)
    # 将 l2_loss添加到loss中
    slim.losses.add_loss(l2_loss)

    totalloss = slim.losses.get_total_loss()
    # 这里为了后面做日志,这里把l2_loss也传出
    return totalloss, l2_loss

Train部分代码编写

初代Train代码

import os
import tensorflow as tf
import readcifar10
from tqdm import tqdm
slim = tf.contrib.slim


slim = tf.contrib.slim


def model(image, keep_prob=0.8, is_training=True):
    """
    在model中我们会定义网络结构
    params
    image: 输入的图片

    return 概率分布值 10 dim vector
    """

    # batchnorm的参数
    batch_norm_params = {
        "is_training": is_training,  # train:True test:False
        "epsilon": 1e-5,  # 这个值是防止batchnorm在归一化的时候除0
        "decay": 0.997,  # 衰减系数
        'scale': True,
        'updates_collections': tf.GraphKeys.UPDATE_OPS
    }

    """
    定义优化器
    用 slim.arg_scope()为目标函数设置默认参数.
    下面两个with,完成卷积默认参数的初始化和pooling层默认参数的初始化
    一个with就是一个参数域 网络可以使用通过的参数
    """
    with slim.arg_scope(
        [slim.conv2d],  # 这里是给 slim.conv2d 规定过了后面的参数
        weights_initializer=slim.variance_scaling_initializer(),  # 方差尺度不变来进行初始化
        activation_fn=tf.nn.relu,  # 默认激活函数为relu 在卷积之后加入激活函数
        weights_regularizer=slim.l2_regularizer(
            0.0001),  # 权值的正则化约束 正则项权值为0.0001
        normalizer_fn=slim.batch_norm,  # 在卷积机后加入 BatchNorm
            normalizer_params=batch_norm_params):

        with slim.arg_scope([slim.max_pool2d], padding="SAME"):  # 给 slim.max_pool2d 规定参数
            """
            接下来利用卷积层、池化层、全连接层搭建一个cifar10用于图像分类的全连接网
            """
            # 输入image 学习32个卷积核(channel) 卷积核大小 [3,3] 卷积层命名 conv1
            net = slim.conv2d(image, 32, [3, 3], scope='conv1')
            # 输入net 学习32个卷积核 卷积核大小 [3,3] 卷积层命名 conv2
            net = slim.conv2d(net, 32, [3, 3], scope='conv2')
            # 输入net 池化核大小[3,3] stride=2(进行两倍下采样)
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool1')
            """
            ===========
            上面 conv+conv+maxpool 算是一个基本单元,后面基本就是使用这样的基本单元进行堆叠
            ==========
            """
            # 每次经过pooling之后 卷积层channel的数量应该翻倍
            net = slim.conv2d(net, 64, [3, 3], scope='conv3')
            net = slim.conv2d(net, 64, [3, 3], scope='conv4')
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool2')
            net = slim.conv2d(net, 128, [3, 3], scope='conv5')
            net = slim.conv2d(net, 128, [3, 3], scope='conv6')
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool3')
            # 经过8倍下采样之后 在加入一个卷积层
            net = slim.conv2d(net, 256, [3, 3], scope='conv7')
            """
            特征图维度 (n,h,w,c)
            对 h,w 进行均值的求解 得到 (n,1,1,c) 因为 reduce_mean 就是降维求平均
            """
            net = tf.reduce_mean(net, axis=[1, 2])  # nhwc--n11c
            """
            slim.flatten 将输入扁平化但保留batch_size,假设第一维是batch。
            将 (n,1,1,c) 转为 (n,c)
            """
            net = slim.flatten(net)
            # 全连接层 这里还不着急分类 (1,1024)可以作为从图像中提取出来的特征
            net = slim.fully_connected(net, 1024)
            """
            全连接层的参数太多 要加入dropout层 来进行正则化
            keep_prob 概率值 定义了我们对当前神经元选择的概率
            在训练和测试的时候,这个概率要取不同的值 训练的时候要取<1 测试的时候要=1
            """
            slim.dropout(net, keep_prob)
            # 输出为10 对应了10个分类类别
            net = slim.fully_connected(net, 10)
    return net  # 10 dim vec


def loss(logits, label):
    """
    loss使用交叉熵损失函数
    param
    logits: 预测出来的概率分布值
    label: 实际的label

    return 分类的loss
    """
    # 对label进行one-hot编码 定义one-hot长度为10
    one_hot_label = slim.one_hot_encoding(label, 10)
    # 使用交叉熵损失函数 并传入 预测值 和 one-hot label
    slim.losses.softmax_cross_entropy(logits, one_hot_label)

    """
    在前面 slim.arg_scope 中定义了weights_regularizer=slim.l2_regularizer(0.0001)
    通过 tf.GraphKeys.REGULARIZATION_LOSSES 可以拿到这些loss正则化的集合
    """
    reg_set = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
    # 将这些正则化loss进行相加 计算出总体的l2_loss
    l2_loss = tf.add_n(reg_set)
    # 将 l2_loss添加到loss中
    slim.losses.add_loss(l2_loss)

    totalloss = slim.losses.get_total_loss()
    # 这里为了后面做日志,这里把l2_loss也传出
    return totalloss, l2_loss


def func_optimal(batchsize, loss_val):
    """
    定义优化器
    """
    global_step = tf.Variable(0, trainable=False)
    # 通过指数衰减的形式来定义学习率
    lr = tf.train.exponential_decay(0.01,
                                    global_step,
                                    decay_steps=50000 // batchsize,
                                    decay_rate=0.95,
                                    staircase=False)

    update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)

    with tf.control_dependencies(update_ops):
        op = tf.train.AdamOptimizer(lr).minimize(loss_val, global_step)

    """
    global_step 可以得到当前的迭代次数
    op sess.run()执行op可以完成对网络参数的调节
    lr 返回 便于log信息的记录
    """
    return global_step, op, lr


def train():
    batchsize = 64
    floder_log = 'logdirs'
    floder_model = 'model'

    if not os.path.exists(floder_log):
        os.mkdir(floder_log)

    if not os.path.exists(floder_model):
        os.mkdir(floder_model)

    # data
    tr_im, tr_label = readcifar10.read(batchsize, 0, 1)
    te_im, te_label = readcifar10.read(batchsize, 1, 0)

    # net
    """
    tf.placeholder 此函数可以理解为形参,用于定义过程,在执行的时候再赋具体的值
    训练数据 [None,32,32,3] None是考虑到batch_size是可以变化的
    """
    input_data = tf.placeholder(tf.float32, shape=[None, 32, 32, 3],
                                name='input_data')

    input_label = tf.placeholder(tf.int64, shape=[None],
                                 name='input_label')
    """
    keep_prob dropout的概率值
    训练过程 keep_prob 也就是dropout的概率值 为0.5 或小于1的值
    """
    keep_prob = tf.placeholder(tf.float32, shape=None,
                               name='keep_prob')

    is_training = tf.placeholder(tf.bool, shape=None,
                                 name='is_training')

    logits = model(
        input_data, keep_prob=keep_prob, is_training=is_training)

    # loss
    """
    损失函数 传入预测的结果和真实的标签
    """
    total_loss, l2_loss = loss(logits, input_label)

    # accurancy
    """
    tf.argmax 获取最大值的索引
    [n,10] axis=1 计算的是10维这个维度最大值对应的索引值
    """
    pred_max = tf.argmax(logits, 1)
    # 判断最大值索引和 label是否相等
    correct = tf.equal(pred_max, input_label)
    accurancy = tf.reduce_mean(tf.cast(correct, tf.float32))

    # op
    global_step, op, lr = func_optimal(batchsize, total_loss)

    with tf.Session() as sess:
        # 初始化参数 包括了局部变量和全局变量
        sess.run(tf.group(tf.global_variables_initializer(),
                          tf.local_variables_initializer()))
        # 启动文件队列写入的线程
        tf.train.start_queue_runners(sess=sess,
                                     coord=tf.train.Coordinator())

        epoch_val = 10

        # 读取文件队列中的数据,完成对网络的训练
        for i in tqdm(range(50000 * epoch_val)):
            train_im_batch, train_label_batch = 
                sess.run([tr_im, tr_label])

            feed_dict = {
                input_data: train_im_batch,
                input_label: train_label_batch,
                keep_prob: 0.8,
                is_training: True
            }

            # 注意 这里得到这这些值 都是一个batch_size的
            _, global_step_val, 
                lr_val, 
                total_loss_val, 
                accurancy_val = sess.run([op,
                                          global_step,
                                          lr,
                                          total_loss,
                                          accurancy],
                                         feed_dict=feed_dict)

            # 每隔一百次打印一次
            if i % 20 == 0:
                print("
{},{},{},{}".format(global_step_val,
                lr_val, 
                total_loss_val,
                accurancy_val))

    return


if __name__ == '__main__':
    train()

Test部分代码编写

在完成一部分train,可以进行test

import os
import tensorflow as tf
import readcifar10
from tqdm import tqdm
slim = tf.contrib.slim


slim = tf.contrib.slim


def model(image, keep_prob=0.8, is_training=True):
    """
    在model中我们会定义网络结构
    params
    image: 输入的图片

    return 概率分布值 10 dim vector
    """

    # batchnorm的参数
    batch_norm_params = {
        "is_training": is_training,  # train:True test:False
        "epsilon": 1e-5,  # 这个值是防止batchnorm在归一化的时候除0
        "decay": 0.997,  # 衰减系数
        'scale': True,
        'updates_collections': tf.GraphKeys.UPDATE_OPS
    }

    """
    定义优化器
    用 slim.arg_scope()为目标函数设置默认参数.
    下面两个with,完成卷积默认参数的初始化和pooling层默认参数的初始化
    一个with就是一个参数域 网络可以使用通过的参数
    """
    with slim.arg_scope(
        [slim.conv2d],  # 这里是给 slim.conv2d 规定过了后面的参数
        weights_initializer=slim.variance_scaling_initializer(),  # 方差尺度不变来进行初始化
        activation_fn=tf.nn.relu,  # 默认激活函数为relu 在卷积之后加入激活函数
        weights_regularizer=slim.l2_regularizer(
            0.0001),  # 权值的正则化约束 正则项权值为0.0001
        normalizer_fn=slim.batch_norm,  # 在卷积机后加入 BatchNorm
            normalizer_params=batch_norm_params):

        with slim.arg_scope([slim.max_pool2d], padding="SAME"):  # 给 slim.max_pool2d 规定参数
            """
            接下来利用卷积层、池化层、全连接层搭建一个cifar10用于图像分类的全连接网
            """
            # 输入image 学习32个卷积核(channel) 卷积核大小 [3,3] 卷积层命名 conv1
            net = slim.conv2d(image, 32, [3, 3], scope='conv1')
            # 输入net 学习32个卷积核 卷积核大小 [3,3] 卷积层命名 conv2
            net = slim.conv2d(net, 32, [3, 3], scope='conv2')
            # 输入net 池化核大小[3,3] stride=2(进行两倍下采样)
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool1')
            """
            ===========
            上面 conv+conv+maxpool 算是一个基本单元,后面基本就是使用这样的基本单元进行堆叠
            ==========
            """
            # 每次经过pooling之后 卷积层channel的数量应该翻倍
            net = slim.conv2d(net, 64, [3, 3], scope='conv3')
            net = slim.conv2d(net, 64, [3, 3], scope='conv4')
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool2')
            net = slim.conv2d(net, 128, [3, 3], scope='conv5')
            net = slim.conv2d(net, 128, [3, 3], scope='conv6')
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool3')
            # 经过8倍下采样之后 在加入一个卷积层
            net = slim.conv2d(net, 256, [3, 3], scope='conv7')
            """
            特征图维度 (n,h,w,c)
            对 h,w 进行均值的求解 得到 (n,1,1,c) 因为 reduce_mean 就是降维求平均
            """
            net = tf.reduce_mean(net, axis=[1, 2])  # nhwc--n11c
            """
            slim.flatten 将输入扁平化但保留batch_size,假设第一维是batch。
            将 (n,1,1,c) 转为 (n,c)
            """
            net = slim.flatten(net)
            # 全连接层 这里还不着急分类 (1,1024)可以作为从图像中提取出来的特征
            net = slim.fully_connected(net, 1024)
            """
            全连接层的参数太多 要加入dropout层 来进行正则化
            keep_prob 概率值 定义了我们对当前神经元选择的概率
            在训练和测试的时候,这个概率要取不同的值 训练的时候要取<1 测试的时候要=1
            """
            slim.dropout(net, keep_prob)
            # 输出为10 对应了10个分类类别
            net = slim.fully_connected(net, 10)
    return net  # 10 dim vec


def loss(logits, label):
    """
    loss使用交叉熵损失函数
    param
    logits: 预测出来的概率分布值
    label: 实际的label

    return 分类的loss
    """
    # 对label进行one-hot编码 定义one-hot长度为10
    one_hot_label = slim.one_hot_encoding(label, 10)
    # 使用交叉熵损失函数 并传入 预测值 和 one-hot label
    slim.losses.softmax_cross_entropy(logits, one_hot_label)

    """
    在前面 slim.arg_scope 中定义了weights_regularizer=slim.l2_regularizer(0.0001)
    通过 tf.GraphKeys.REGULARIZATION_LOSSES 可以拿到这些loss正则化的集合
    """
    reg_set = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
    # 将这些正则化loss进行相加 计算出总体的l2_loss
    l2_loss = tf.add_n(reg_set)
    # 将 l2_loss添加到loss中
    slim.losses.add_loss(l2_loss)

    totalloss = slim.losses.get_total_loss()
    # 这里为了后面做日志,这里把l2_loss也传出
    return totalloss, l2_loss


def func_optimal(batchsize, loss_val):
    """
    定义优化器
    """
    global_step = tf.Variable(0, trainable=False)
    # 通过指数衰减的形式来定义学习率
    lr = tf.train.exponential_decay(0.01,
                                    global_step,
                                    decay_steps=50000 // batchsize,
                                    decay_rate=0.95,
                                    staircase=False)

    update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)

    with tf.control_dependencies(update_ops):
        op = tf.train.AdamOptimizer(lr).minimize(loss_val, global_step)

    """
    global_step 可以得到当前的迭代次数
    op sess.run()执行op可以完成对网络参数的调节
    lr 返回 便于log信息的记录
    """
    return global_step, op, lr


def train():
    batchsize = 64
    floder_log = 'logdirs'
    floder_model = 'model'

    if not os.path.exists(floder_log):
        os.mkdir(floder_log)

    if not os.path.exists(floder_model):
        os.mkdir(floder_model)

    # data
    tr_im, tr_label = readcifar10.read(batchsize, 0, 1)
    te_im, te_label = readcifar10.read(batchsize, 1, 0)

    # net
    """
    tf.placeholder 此函数可以理解为形参,用于定义过程,在执行的时候再赋具体的值
    训练数据 [None,32,32,3] None是考虑到batch_size是可以变化的
    """
    input_data = tf.placeholder(tf.float32, shape=[None, 32, 32, 3],
                                name='input_data')

    input_label = tf.placeholder(tf.int64, shape=[None],
                                 name='input_label')
    """
    keep_prob dropout的概率值
    训练过程 keep_prob 也就是dropout的概率值 为0.5 或小于1的值
    """
    keep_prob = tf.placeholder(tf.float32, shape=None,
                               name='keep_prob')

    is_training = tf.placeholder(tf.bool, shape=None,
                                 name='is_training')

    logits = model(
        input_data, keep_prob=keep_prob, is_training=is_training)

    # loss
    """
    损失函数 传入预测的结果和真实的标签
    """
    total_loss, l2_loss = loss(logits, input_label)

    # accurancy
    """
    tf.argmax 获取最大值的索引
    [n,10] axis=1 计算的是10维这个维度最大值对应的索引值
    """
    pred_max = tf.argmax(logits, 1)
    # 判断最大值索引和 label是否相等
    correct = tf.equal(pred_max, input_label)
    accurancy = tf.reduce_mean(tf.cast(correct, tf.float32))

    # op
    global_step, op, lr = func_optimal(batchsize, total_loss)

    with tf.Session() as sess:
        # 初始化参数 包括了局部变量和全局变量
        sess.run(tf.group(tf.global_variables_initializer(),
                          tf.local_variables_initializer()))
        # 启动文件队列写入的线程
        tf.train.start_queue_runners(sess=sess,
                                     coord=tf.train.Coordinator())

        epoch_val = 10

        # 读取文件队列中的数据,完成对网络的训练
        for i in tqdm(range(50000 * epoch_val)): # 这里这个数量我还是没有理解
            train_im_batch, train_label_batch = 
                sess.run([tr_im, tr_label])

            feed_dict = {
                input_data: train_im_batch,
                input_label: train_label_batch,
                keep_prob: 0.8,
                is_training: True
            }

            # 注意 这里得到这这些值 都是一个batch_size的
            _, global_step_val, 
                lr_val, 
                total_loss_val, 
                accurancy_val = sess.run([op,
                                          global_step,
                                          lr,
                                          total_loss,
                                          accurancy],
                                         feed_dict=feed_dict)

            # 每隔一百次打印一次
            if i % 100 == 0:
                print("
[trian]:{},{},{},{}".format(global_step_val,
                lr_val, 
                total_loss_val,
                accurancy_val))
            
            # 隔一段时间进行测试
            if i % (50000 // batchsize) == 0:
                test_loss = 0
                test_acc = 0
                for ii in range(10000//batchsize):
                    test_im_batch, test_label_batch = 
                        sess.run([te_im, te_label])
                    feed_dict = {
                        input_data: test_im_batch,
                        input_label: test_label_batch,
                        keep_prob: 1.0,
                        is_training: False
                    }

                    total_loss_val, global_step_val, 
                    accurancy_val = sess.run([total_loss,global_step,
                                              accurancy],
                                             feed_dict=feed_dict)

                    test_loss += total_loss_val
                    test_acc += accurancy_val

                print('[test]:', test_loss * batchsize / 10000,
                      test_acc* batchsize / 10000)
    return


if __name__ == '__main__':
    train()

Tensorboard+tf.summary

因为查看训练的消息只能在控制台查看,所以这里要记录日志信息。

训练好会输出日志,如下图。

如何查看该日志呢?在终端输入以下命令

tensorboard --logdir=logdirs

import os
import tensorflow as tf
import readcifar10
from tqdm import tqdm
slim = tf.contrib.slim


slim = tf.contrib.slim


def model(image, keep_prob=0.8, is_training=True):
    """
    在model中我们会定义网络结构
    params
    image: 输入的图片

    return 概率分布值 10 dim vector
    """

    # batchnorm的参数
    batch_norm_params = {
        "is_training": is_training,  # train:True test:False
        "epsilon": 1e-5,  # 这个值是防止batchnorm在归一化的时候除0
        "decay": 0.997,  # 衰减系数
        'scale': True,
        'updates_collections': tf.GraphKeys.UPDATE_OPS
    }

    """
    定义优化器
    用 slim.arg_scope()为目标函数设置默认参数.
    下面两个with,完成卷积默认参数的初始化和pooling层默认参数的初始化
    一个with就是一个参数域 网络可以使用通过的参数
    """
    with slim.arg_scope(
        [slim.conv2d],  # 这里是给 slim.conv2d 规定过了后面的参数
        weights_initializer=slim.variance_scaling_initializer(),  # 方差尺度不变来进行初始化
        activation_fn=tf.nn.relu,  # 默认激活函数为relu 在卷积之后加入激活函数
        weights_regularizer=slim.l2_regularizer(
            0.0001),  # 权值的正则化约束 正则项权值为0.0001
        normalizer_fn=slim.batch_norm,  # 在卷积机后加入 BatchNorm
            normalizer_params=batch_norm_params):

        with slim.arg_scope([slim.max_pool2d], padding="SAME"):  # 给 slim.max_pool2d 规定参数
            """
            接下来利用卷积层、池化层、全连接层搭建一个cifar10用于图像分类的全连接网
            """
            # 输入image 学习32个卷积核(channel) 卷积核大小 [3,3] 卷积层命名 conv1
            net = slim.conv2d(image, 32, [3, 3], scope='conv1')
            # 输入net 学习32个卷积核 卷积核大小 [3,3] 卷积层命名 conv2
            net = slim.conv2d(net, 32, [3, 3], scope='conv2')
            # 输入net 池化核大小[3,3] stride=2(进行两倍下采样)
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool1')
            """
            ===========
            上面 conv+conv+maxpool 算是一个基本单元,后面基本就是使用这样的基本单元进行堆叠
            ==========
            """
            # 每次经过pooling之后 卷积层channel的数量应该翻倍
            net = slim.conv2d(net, 64, [3, 3], scope='conv3')
            net = slim.conv2d(net, 64, [3, 3], scope='conv4')
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool2')
            net = slim.conv2d(net, 128, [3, 3], scope='conv5')
            net = slim.conv2d(net, 128, [3, 3], scope='conv6')
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool3')
            # 经过8倍下采样之后 在加入一个卷积层
            net = slim.conv2d(net, 256, [3, 3], scope='conv7')
            """
            特征图维度 (n,h,w,c)
            对 h,w 进行均值的求解 得到 (n,1,1,c) 因为 reduce_mean 就是降维求平均
            """
            net = tf.reduce_mean(net, axis=[1, 2])  # nhwc--n11c
            """
            slim.flatten 将输入扁平化但保留batch_size,假设第一维是batch。
            将 (n,1,1,c) 转为 (n,c)
            """
            net = slim.flatten(net)
            # 全连接层 这里还不着急分类 (1,1024)可以作为从图像中提取出来的特征
            net = slim.fully_connected(net, 1024)
            """
            全连接层的参数太多 要加入dropout层 来进行正则化
            keep_prob 概率值 定义了我们对当前神经元选择的概率
            在训练和测试的时候,这个概率要取不同的值 训练的时候要取<1 测试的时候要=1
            """
            slim.dropout(net, keep_prob)
            # 输出为10 对应了10个分类类别
            net = slim.fully_connected(net, 10)
    return net  # 10 dim vec


def loss(logits, label):
    """
    loss使用交叉熵损失函数
    param
    logits: 预测出来的概率分布值
    label: 实际的label

    return 分类的loss
    """
    # 对label进行one-hot编码 定义one-hot长度为10
    one_hot_label = slim.one_hot_encoding(label, 10)
    # 使用交叉熵损失函数 并传入 预测值 和 one-hot label
    slim.losses.softmax_cross_entropy(logits, one_hot_label)

    """
    在前面 slim.arg_scope 中定义了weights_regularizer=slim.l2_regularizer(0.0001)
    通过 tf.GraphKeys.REGULARIZATION_LOSSES 可以拿到这些loss正则化的集合
    """
    reg_set = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
    # 将这些正则化loss进行相加 计算出总体的l2_loss
    l2_loss = tf.add_n(reg_set)
    # 将 l2_loss添加到loss中
    slim.losses.add_loss(l2_loss)

    totalloss = slim.losses.get_total_loss()
    # 这里为了后面做日志,这里把l2_loss也传出
    return totalloss, l2_loss


def func_optimal(batchsize, loss_val):
    """
    定义优化器
    """
    global_step = tf.Variable(0, trainable=False)
    # 通过指数衰减的形式来定义学习率
    lr = tf.train.exponential_decay(0.01,
                                    global_step,
                                    decay_steps=50000 // batchsize,
                                    decay_rate=0.95,
                                    staircase=False)

    update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)

    with tf.control_dependencies(update_ops):
        op = tf.train.AdamOptimizer(lr).minimize(loss_val, global_step)

    """
    global_step 可以得到当前的迭代次数
    op sess.run()执行op可以完成对网络参数的调节
    lr 返回 便于log信息的记录
    """
    return global_step, op, lr


def train():
    batchsize = 64
    floder_log = 'logdirs'
    floder_model = 'model'

    if not os.path.exists(floder_log):
        os.mkdir(floder_log)

    if not os.path.exists(floder_model):
        os.mkdir(floder_model)

    # 存放train和test的日志信息
    tr_summary = set()
    te_summary = set()

    # data
    tr_im, tr_label = readcifar10.read(batchsize, 0, 1)
    te_im, te_label = readcifar10.read(batchsize, 1, 0)

    # net
    """
    tf.placeholder 此函数可以理解为形参,用于定义过程,在执行的时候再赋具体的值
    训练数据 [None,32,32,3] None是考虑到batch_size是可以变化的
    """
    input_data = tf.placeholder(tf.float32, shape=[None, 32, 32, 3],
                                name='input_data')

    input_label = tf.placeholder(tf.int64, shape=[None],
                                 name='input_label')
    """
    keep_prob dropout的概率值
    训练过程 keep_prob 也就是dropout的概率值 为0.5 或小于1的值
    """
    keep_prob = tf.placeholder(tf.float32, shape=None,
                               name='keep_prob')

    is_training = tf.placeholder(tf.bool, shape=None,
                                 name='is_training')

    logits = model(
        input_data, keep_prob=keep_prob, is_training=is_training)

    # loss
    """
    损失函数 传入预测的结果和真实的标签
    """
    total_loss, l2_loss = loss(logits, input_label)

    # 记录loss
    tr_summary.add(tf.summary.scalar('train total loss', total_loss))
    tr_summary.add(tf.summary.scalar('test l2_loss', l2_loss))

    te_summary.add(tf.summary.scalar('train total loss', total_loss))
    te_summary.add(tf.summary.scalar('test l2_loss', l2_loss))

    # accurancy
    """
    tf.argmax 获取最大值的索引
    [n,10] axis=1 计算的是10维这个维度最大值对应的索引值
    """
    pred_max = tf.argmax(logits, 1)
    # 判断最大值索引和 label是否相等
    correct = tf.equal(pred_max, input_label)
    accurancy = tf.reduce_mean(tf.cast(correct, tf.float32))

    tr_summary.add(tf.summary.scalar('train accurancy', accurancy))
    te_summary.add(tf.summary.scalar('test accurancy', accurancy))

    # op
    global_step, op, lr = func_optimal(batchsize, total_loss)

    tr_summary.add(tf.summary.scalar('train lr', lr))
    te_summary.add(tf.summary.scalar('test lr', lr))

    # 图片数据是归一化过的 这里要处理回来
    tr_summary.add(tf.summary.image('train image', input_data * 128 + 128))
    te_summary.add(tf.summary.image('test image', input_data * 128 + 128))
    with tf.Session() as sess:
        # 初始化参数 包括了局部变量和全局变量
        sess.run(tf.group(tf.global_variables_initializer(),
                          tf.local_variables_initializer()))
        # 启动文件队列写入的线程
        tf.train.start_queue_runners(sess=sess,
                                     coord=tf.train.Coordinator())

        epoch_val = 10

        # 将日志进行合并
        tr_summary_op = tf.summary.merge(list(tr_summary))
        te_summary_op = tf.summary.merge(list(te_summary))

        summary_writer = tf.summary.FileWriter(floder_log, sess.graph)

        # 读取文件队列中的数据,完成对网络的训练
        for i in tqdm(range(50000 * epoch_val)):  # 这里这个数量我还是没有理解
            train_im_batch, train_label_batch = 
                sess.run([tr_im, tr_label])

            feed_dict = {
                input_data: train_im_batch,
                input_label: train_label_batch,
                keep_prob: 0.8,
                is_training: True
            }

            # 注意 这里得到这这些值 都是一个batch_size的
            _, global_step_val, 
                lr_val, 
                total_loss_val, 
                accurancy_val, tr_summary_str = sess.run([op,
                                                          global_step,
                                                          lr,
                                                          total_loss,
                                                          accurancy, tr_summary_op],
                                                         feed_dict=feed_dict)

            summary_writer.add_summary(tr_summary_str, global_step_val)

            # 每隔一百次打印一次
            if i % 100 == 0:
                print("
[trian]:{},{},{},{}".format(global_step_val,
                                                     lr_val,
                                                     total_loss_val,
                                                     accurancy_val))

            # 隔一段时间进行测试
            if i % (50000 // batchsize) == 0:
                test_loss = 0
                test_acc = 0
                for ii in range(10000//batchsize):
                    test_im_batch, test_label_batch = 
                        sess.run([te_im, te_label])
                    feed_dict = {
                        input_data: test_im_batch,
                        input_label: test_label_batch,
                        keep_prob: 1.0,
                        is_training: False
                    }

                    total_loss_val, global_step_val, 
                    accurancy_val, te_summary_str = sess.run([total_loss,global_step,
                                              accurancy, te_summary_op],
                                             feed_dict=feed_dict)

                    summary_writer.add_summary(te_summary_str, global_step_val)

                    test_loss += total_loss_val
                    test_acc += accurancy_val

                print('[test]:', test_loss * batchsize / 10000,
                      test_acc * batchsize / 10000)
    return


if __name__ == '__main__':
    train()

观察loss,确实是在收敛,但是准确率的震荡还是比较大的。

那么处理的思路有:

  • 减小学习率或加大学习率衰减的值

修改优化器

模型恢复和模型存储

上面的程序没有加入模型存储的代码。

保存的模型代码结果如下

对于tf的model,就是包含了以下几个部分:

  • checkpoint: 指向最新的模型
  • .meta: 定义了graph的结构
  • .data:存放了网络中具体参数的值
  • .index: 完成对data和meta的索引
import os
import tensorflow as tf
import readcifar10
from tqdm import tqdm
slim = tf.contrib.slim


slim = tf.contrib.slim


def model(image, keep_prob=0.8, is_training=True):
    """
    在model中我们会定义网络结构
    params
    image: 输入的图片

    return 概率分布值 10 dim vector
    """

    # batchnorm的参数
    batch_norm_params = {
        "is_training": is_training,  # train:True test:False
        "epsilon": 1e-5,  # 这个值是防止batchnorm在归一化的时候除0
        "decay": 0.997,  # 衰减系数
        'scale': True,
        'updates_collections': tf.GraphKeys.UPDATE_OPS
    }

    """
    定义优化器
    用 slim.arg_scope()为目标函数设置默认参数.
    下面两个with,完成卷积默认参数的初始化和pooling层默认参数的初始化
    一个with就是一个参数域 网络可以使用通过的参数
    """
    with slim.arg_scope(
        [slim.conv2d],  # 这里是给 slim.conv2d 规定过了后面的参数
        weights_initializer=slim.variance_scaling_initializer(),  # 方差尺度不变来进行初始化
        activation_fn=tf.nn.relu,  # 默认激活函数为relu 在卷积之后加入激活函数
        weights_regularizer=slim.l2_regularizer(
            0.0001),  # 权值的正则化约束 正则项权值为0.0001
        normalizer_fn=slim.batch_norm,  # 在卷积机后加入 BatchNorm
            normalizer_params=batch_norm_params):

        with slim.arg_scope([slim.max_pool2d], padding="SAME"):  # 给 slim.max_pool2d 规定参数
            """
            接下来利用卷积层、池化层、全连接层搭建一个cifar10用于图像分类的全连接网
            """
            # 输入image 学习32个卷积核(channel) 卷积核大小 [3,3] 卷积层命名 conv1
            net = slim.conv2d(image, 32, [3, 3], scope='conv1')
            # 输入net 学习32个卷积核 卷积核大小 [3,3] 卷积层命名 conv2
            net = slim.conv2d(net, 32, [3, 3], scope='conv2')
            # 输入net 池化核大小[3,3] stride=2(进行两倍下采样)
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool1')
            """
            ===========
            上面 conv+conv+maxpool 算是一个基本单元,后面基本就是使用这样的基本单元进行堆叠
            ==========
            """
            # 每次经过pooling之后 卷积层channel的数量应该翻倍
            net = slim.conv2d(net, 64, [3, 3], scope='conv3')
            net = slim.conv2d(net, 64, [3, 3], scope='conv4')
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool2')
            net = slim.conv2d(net, 128, [3, 3], scope='conv5')
            net = slim.conv2d(net, 128, [3, 3], scope='conv6')
            net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool3')
            # 经过8倍下采样之后 在加入一个卷积层
            net = slim.conv2d(net, 256, [3, 3], scope='conv7')
            """
            特征图维度 (n,h,w,c)
            对 h,w 进行均值的求解 得到 (n,1,1,c) 因为 reduce_mean 就是降维求平均
            """
            net = tf.reduce_mean(net, axis=[1, 2])  # nhwc--n11c
            """
            slim.flatten 将输入扁平化但保留batch_size,假设第一维是batch。
            将 (n,1,1,c) 转为 (n,c)
            """
            net = slim.flatten(net)
            # 全连接层 这里还不着急分类 (1,1024)可以作为从图像中提取出来的特征
            net = slim.fully_connected(net, 1024)
            """
            全连接层的参数太多 要加入dropout层 来进行正则化
            keep_prob 概率值 定义了我们对当前神经元选择的概率
            在训练和测试的时候,这个概率要取不同的值 训练的时候要取<1 测试的时候要=1
            """
            slim.dropout(net, keep_prob)
            # 输出为10 对应了10个分类类别
            net = slim.fully_connected(net, 10)
    return net  # 10 dim vec


def loss(logits, label):
    """
    loss使用交叉熵损失函数
    param
    logits: 预测出来的概率分布值
    label: 实际的label

    return 分类的loss
    """
    # 对label进行one-hot编码 定义one-hot长度为10
    one_hot_label = slim.one_hot_encoding(label, 10)
    # 使用交叉熵损失函数 并传入 预测值 和 one-hot label
    slim.losses.softmax_cross_entropy(logits, one_hot_label)

    """
    在前面 slim.arg_scope 中定义了weights_regularizer=slim.l2_regularizer(0.0001)
    通过 tf.GraphKeys.REGULARIZATION_LOSSES 可以拿到这些loss正则化的集合
    """
    reg_set = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
    # 将这些正则化loss进行相加 计算出总体的l2_loss
    l2_loss = tf.add_n(reg_set)
    # 将 l2_loss添加到loss中
    slim.losses.add_loss(l2_loss)

    totalloss = slim.losses.get_total_loss()
    # 这里为了后面做日志,这里把l2_loss也传出
    return totalloss, l2_loss


def func_optimal(batchsize, loss_val):
    """
    定义优化器
    """
    global_step = tf.Variable(0, trainable=False)
    # 通过指数衰减的形式来定义学习率
    lr = tf.train.exponential_decay(0.01,
                                    global_step,
                                    decay_steps=50000 // batchsize,
                                    decay_rate=0.95,
                                    staircase=False)

    update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)

    with tf.control_dependencies(update_ops):
        op = tf.train.AdamOptimizer(lr).minimize(loss_val, global_step)

    """
    global_step 可以得到当前的迭代次数
    op sess.run()执行op可以完成对网络参数的调节
    lr 返回 便于log信息的记录
    """
    return global_step, op, lr


def train():
    batchsize = 64
    floder_log = 'logdirs'
    floder_model = 'model'

    if not os.path.exists(floder_log):
        os.mkdir(floder_log)

    if not os.path.exists(floder_model):
        os.mkdir(floder_model)

    # 存放train和test的日志信息
    tr_summary = set()
    te_summary = set()

    # data
    tr_im, tr_label = readcifar10.read(batchsize, 0, 1)
    te_im, te_label = readcifar10.read(batchsize, 1, 0)

    # net
    """
    tf.placeholder 此函数可以理解为形参,用于定义过程,在执行的时候再赋具体的值
    训练数据 [None,32,32,3] None是考虑到batch_size是可以变化的
    """
    input_data = tf.placeholder(tf.float32, shape=[None, 32, 32, 3],
                                name='input_data')

    input_label = tf.placeholder(tf.int64, shape=[None],
                                 name='input_label')
    """
    keep_prob dropout的概率值
    训练过程 keep_prob 也就是dropout的概率值 为0.5 或小于1的值
    """
    keep_prob = tf.placeholder(tf.float32, shape=None,
                               name='keep_prob')

    is_training = tf.placeholder(tf.bool, shape=None,
                                 name='is_training')

    logits = model(
        input_data, keep_prob=keep_prob, is_training=is_training)

    # loss
    """
    损失函数 传入预测的结果和真实的标签
    """
    total_loss, l2_loss = loss(logits, input_label)

    # 记录loss
    tr_summary.add(tf.summary.scalar('train total loss', total_loss))
    tr_summary.add(tf.summary.scalar('test l2_loss', l2_loss))

    te_summary.add(tf.summary.scalar('train total loss', total_loss))
    te_summary.add(tf.summary.scalar('test l2_loss', l2_loss))

    # accurancy
    """
    tf.argmax 获取最大值的索引
    [n,10] axis=1 计算的是10维这个维度最大值对应的索引值
    """
    pred_max = tf.argmax(logits, 1)
    # 判断最大值索引和 label是否相等
    correct = tf.equal(pred_max, input_label)
    accurancy = tf.reduce_mean(tf.cast(correct, tf.float32))

    tr_summary.add(tf.summary.scalar('train accurancy', accurancy))
    te_summary.add(tf.summary.scalar('test accurancy', accurancy))

    # op
    global_step, op, lr = func_optimal(batchsize, total_loss)

    tr_summary.add(tf.summary.scalar('train lr', lr))
    te_summary.add(tf.summary.scalar('test lr', lr))

    # 图片数据是归一化过的 这里要处理回来
    tr_summary.add(tf.summary.image('train image', input_data * 128 + 128))
    te_summary.add(tf.summary.image('test image', input_data * 128 + 128))
    with tf.Session() as sess:
        # 初始化参数 包括了局部变量和全局变量
        sess.run(tf.group(tf.global_variables_initializer(),
                          tf.local_variables_initializer()))
        # 启动文件队列写入的线程
        tf.train.start_queue_runners(sess=sess,
                                     coord=tf.train.Coordinator())

        saver = tf.train.Saver(tf.global_variables(), max_to_keep=5)
        ckpt = tf.train.latest_checkpoint(floder_model)

        if ckpt:
            saver.restore(sess, ckpt)
        epoch_val = 10

        # 将日志进行合并
        tr_summary_op = tf.summary.merge(list(tr_summary))
        te_summary_op = tf.summary.merge(list(te_summary))

        summary_writer = tf.summary.FileWriter(floder_log, sess.graph)

        # 读取文件队列中的数据,完成对网络的训练
        for i in tqdm(range(50000 * epoch_val)):  # 这里这个数量我还是没有理解
            train_im_batch, train_label_batch = 
                sess.run([tr_im, tr_label])

            feed_dict = {
                input_data: train_im_batch,
                input_label: train_label_batch,
                keep_prob: 0.8,
                is_training: True
            }

            # 注意 这里得到这这些值 都是一个batch_size的
            _, global_step_val, 
                lr_val, 
                total_loss_val, 
                accurancy_val, tr_summary_str = sess.run([op,
                                                          global_step,
                                                          lr,
                                                          total_loss,
                                                          accurancy, tr_summary_op],
                                                         feed_dict=feed_dict)

            summary_writer.add_summary(tr_summary_str, global_step_val)

            # 每隔一百次打印一次
            if i % 100 == 0:
                print("
[trian]:{},{},{},{}".format(global_step_val,
                                                     lr_val,
                                                     total_loss_val,
                                                     accurancy_val))

            # 隔一段时间进行测试
            if i % (50000 // batchsize) == 0:
                test_loss = 0
                test_acc = 0
                for ii in range(10000//batchsize):
                    test_im_batch, test_label_batch = 
                        sess.run([te_im, te_label])
                    feed_dict = {
                        input_data: test_im_batch,
                        input_label: test_label_batch,
                        keep_prob: 1.0,
                        is_training: False
                    }

                    total_loss_val, global_step_val, 
                    accurancy_val, te_summary_str = sess.run([total_loss,global_step,
                                              accurancy, te_summary_op],
                                             feed_dict=feed_dict)

                    summary_writer.add_summary(te_summary_str, global_step_val)

                    test_loss += total_loss_val
                    test_acc += accurancy_val

                print('[test]:', test_loss * batchsize / 10000,
                      test_acc * batchsize / 10000)
            
            if i % 1000 == 0:
                saver.save(sess, "{}/model.ckpt{}".format(floder_model, str(global_step_val)))

if __name__ == '__main__':
    train()

网络结构优化—resnet模型

上面就是一个完整的网络结构了,如果要对模型进行优化,通常需要修改哪几个地方?

  • 一个就是修改网络结构,这里也称之为主干网络结构,上面是非常简单的串联的网络结构,这里可以使用resnet来这种跳连的结构来进行替代。

  • 还有就是可以修改学习率参数,以及学习率衰减的策略,针对不同的策略,观察对网络性能的影响。

  • 加入更多数据增强的方法,采用不同的优化器来进行模型的训练。

resnet.py

import tensorflow as tf
slim = tf.contrib.slim

def resnet_blockneck(net, numout, down, stride, is_training):
    """
    resnet的基本单元
    params
    net: 输入的特征图
    numout: 输出channel的数量
    down:在resnet中1*1卷积核下采样的倍率
    stride:下采样步长
    is_training: batchnorm的参数
    """
    batch_norm_params = {
    'is_training': is_training,
    'decay': 0.997,
    'epsilon': 1e-5,
    'scale': True,
    'updates_collections': tf.GraphKeys.UPDATE_OPS,
    }
    # 下面定义了卷积层的作用域
    with slim.arg_scope(
                [slim.conv2d],
                weights_regularizer=slim.l2_regularizer(0.0001),
                weights_initializer=slim.variance_scaling_initializer(),
                activation_fn=tf.nn.relu,
                normalizer_fn=slim.batch_norm,
                normalizer_params=batch_norm_params):
        with slim.arg_scope([slim.batch_norm], **batch_norm_params):
            with slim.arg_scope([slim.conv2d, slim.max_pool2d], padding='SAME') as arg_sc:
                """
                对于resnet,首先要将输入的特征图进行备份
                """
                shortcut = net
                """
                并且对备份过之后的特征图需要进行卷积和池化的判断
                主要就是判断channel的数量是否相等 如果不相等就要使用1*1的卷积核进行卷积

                如果是stride=2那么就进行下采样 保证特征图的大小也是一样的
                """
                if numout != net.get_shape().as_list()[-1]:
                    shortcut = slim.conv2d(net, numout, [1, 1])

                if stride != 1:
                    shortcut = slim.max_pool2d(shortcut, [3, 3],
                                               stride=stride)
                """
                先是使用1*1卷积核对channel数量进行下降
                才经过3*3的卷积
                最后通过1*1的卷积还原到想要输出的channel的数量
                """
                net = slim.conv2d(net, numout // down, [1, 1])
                net = slim.conv2d(net, numout // down, [3, 3])
                net = slim.conv2d(net, numout, [1, 1])

                if stride != 1:
                    net = slim.max_pool2d(net, [3, 3], stride=stride)

                # 跳连结构
                net = net + shortcut

                return net


def model_resnet(net, keep_prob=0.5, is_training = True):
    with slim.arg_scope([slim.conv2d, slim.max_pool2d], padding='SAME') as arg_sc:
        """
        输入图像的时候,还是会使用标准卷积
        """
        net = slim.conv2d(net, 64, [3, 3], activation_fn=tf.nn.relu)
        net = slim.conv2d(net, 64, [3, 3], activation_fn=tf.nn.relu)
        """
        在网络结构中 对resnet基本单元进行了堆叠
        每次经过下采样 会对channel进行进行翻倍处理

        这里就是把之前的卷积单元替换成了resnet单元 其他都是一样的
        """
        net = resnet_blockneck(net, 128, 4, 2, is_training)
        net = resnet_blockneck(net, 128, 4, 1, is_training)
        net = resnet_blockneck(net, 256, 4, 2, is_training)
        net = resnet_blockneck(net, 256, 4, 1, is_training)
        net = resnet_blockneck(net, 512, 4, 2, is_training)
        net = resnet_blockneck(net, 512, 4, 1, is_training)

        net = tf.reduce_mean(net, [1, 2])
        net = slim.flatten(net)

        net = slim.fully_connected(net, 1024, activation_fn=tf.nn.relu, scope='fc1')
        net = slim.dropout(net, keep_prob, scope='dropout1')
        net = slim.fully_connected(net, 10, activation_fn=None, scope='fc2')

    return net

train_resnet.py

import tensorflow as tf
import readcifar10
import os
import resnet
from tqdm import tqdm

slim = tf.contrib.slim

def loss(logits, label):

    one_hot_label = slim.one_hot_encoding(label, 10)
    slim.losses.softmax_cross_entropy(logits, one_hot_label)

    reg_set = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
    l2_loss = tf.add_n(reg_set)
    slim.losses.add_loss(l2_loss)

    totalloss = slim.losses.get_total_loss()

    return totalloss, l2_loss

def func_optimal(batchsize, loss_val):
    global_step = tf.Variable(0, trainable=False)
    lr = tf.train.exponential_decay(0.01,
                                    global_step,
                                    decay_steps= 50000// batchsize,
                                    decay_rate= 0.95,
                                    staircase=False)
    update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)

    with tf.control_dependencies(update_ops):
        op = tf.train.AdamOptimizer(lr).minimize(loss_val, global_step)
    return global_step, op, lr

def train():
    batchsize = 64
    floder_log = 'logdirs-resnet'
    floder_model = 'model-resnet'

    if not os.path.exists(floder_log):
        os.mkdir(floder_log)

    if not os.path.exists(floder_model):
        os.mkdir(floder_model)

    tr_summary = set()
    te_summary = set()

    ##data
    tr_im, tr_label = readcifar10.read(batchsize, 0, 1)
    te_im, te_label = readcifar10.read(batchsize, 1, 0)

    ##net
    input_data = tf.placeholder(tf.float32, shape=[None, 32, 32, 3],
                                name='input_data')

    input_label = tf.placeholder(tf.int64, shape=[None],
                                name='input_label')
    keep_prob = tf.placeholder(tf.float32, shape=None,
                                name='keep_prob')

    is_training = tf.placeholder(tf.bool, shape=None,
                               name='is_training')
    logits = resnet.model_resnet(input_data, keep_prob=keep_prob, is_training=is_training)

    ##loss

    total_loss, l2_loss = loss(logits, input_label)

    tr_summary.add(tf.summary.scalar('train total loss', total_loss))
    tr_summary.add(tf.summary.scalar('test l2_loss', l2_loss))

    te_summary.add(tf.summary.scalar('train total loss', total_loss))
    te_summary.add(tf.summary.scalar('test l2_loss', l2_loss))

    ##accurancy
    pred_max  = tf.argmax(logits, 1)
    correct = tf.equal(pred_max, input_label)
    accurancy = tf.reduce_mean(tf.cast(correct, tf.float32))
    tr_summary.add(tf.summary.scalar('train accurancy', accurancy))
    te_summary.add(tf.summary.scalar('test accurancy', accurancy))
    ##op
    global_step, op, lr = func_optimal(batchsize, total_loss)
    tr_summary.add(tf.summary.scalar('train lr', lr))
    te_summary.add(tf.summary.scalar('test lr', lr))

    tr_summary.add(tf.summary.image('train image', input_data * 128 + 128))
    te_summary.add(tf.summary.image('test image', input_data * 128 + 128))

    with tf.Session() as sess:
        sess.run(tf.group(tf.global_variables_initializer(),
                          tf.local_variables_initializer()))

        tf.train.start_queue_runners(sess=sess,
                                     coord=tf.train.Coordinator())

        saver = tf.train.Saver(tf.global_variables(), max_to_keep=5)

        ckpt = tf.train.latest_checkpoint(floder_model)

        if ckpt:
            saver.restore(sess, ckpt)

        epoch_val = 100

        tr_summary_op = tf.summary.merge(list(tr_summary))
        te_summary_op = tf.summary.merge(list(te_summary))

        summary_writer = tf.summary.FileWriter(floder_log, sess.graph)

        for i in tqdm(range(50000 * epoch_val)):
            train_im_batch, train_label_batch = 
                sess.run([tr_im, tr_label])
            feed_dict = {
                input_data:train_im_batch,
                input_label:train_label_batch,
                keep_prob:0.8,
                is_training:True
            }

            _, global_step_val, 
            lr_val, 
            total_loss_val, 
            accurancy_val, tr_summary_str = sess.run([op,
                                      global_step,
                                      lr,
                                      total_loss,
                                      accurancy, tr_summary_op],
                     feed_dict=feed_dict)

            summary_writer.add_summary(tr_summary_str, global_step_val)

            if i % 100 == 0:
                print("{},{},{},{}".format(global_step_val,
                                           lr_val, total_loss_val,
                                           accurancy_val))

            if i % (50000 // batchsize) == 0:
                test_loss = 0
                test_acc = 0
                for ii in range(10000//batchsize):
                    test_im_batch, test_label_batch = 
                        sess.run([te_im, te_label])
                    feed_dict = {
                        input_data: test_im_batch,
                        input_label: test_label_batch,
                        keep_prob: 1.0,
                        is_training: False
                    }

                    total_loss_val, global_step_val, 
                    accurancy_val, te_summary_str = sess.run([total_loss,global_step,
                                              accurancy, te_summary_op],
                                             feed_dict=feed_dict)

                    summary_writer.add_summary(te_summary_str, global_step_val)

                    test_loss += total_loss_val
                    test_acc += accurancy_val

                print('test:', test_loss * batchsize / 10000,
                      test_acc* batchsize / 10000)

            if i % 1000 == 0:
                saver.save(sess, "{}/model.ckpt{}".format(floder_model, str(global_step_val)))
    return

if __name__ == '__main__':
    train()

TF官方版本训练Cifar10分类任务

上面所有的步骤,在官方给出的源码中,其实都已经实现了!

要避免重复造轮子,可以对找官方给出的参考代码进行修改。

https://github.com/tensorflow/models/tree/master/research/slim

好好读读人家的README,会有巨大的收获!

小结

TF训练框架搭建:

*   Data
首先是数据的读取和数据的打包。

*   Net
网络的搭建,这里采用slim来搭建网络结构,因为slim是对tf更加高层的封装,可以写更加简洁的代码。

*   Loss
Loss本身就是网络的一部分,这个会采用softmaxLoss来进行Loss定义。
另外还会定义正则化的Loss。

*   Summary
Summary完成了训练过程中日志的记录。

*   Session
Session完成了构造出网络结构后,如果对计算图中的结点进行计算,会通过Session在后端完成整个网络的BP。并通过Feed给网络数据,Fetch获得输出的张量。

有哪些优化模型效果的思路?

训练代码,也就是baseline版本,要如何进行优化呢?上面提供了几个参考思路。

*   更多的数据增强策略,比如:mixup等=
通过数据增强的策略,来丰富样本量,进而提高模型对更多样本的泛化能力。

*   更好的主干网络,比如:SENet等
有VGG,ResNet这样的主干网络,当然,SENet比ResNet的性能更好,可以实验哪个主干网络实验出来的效果更好。

*   更好的标签策略,比如:Soft-label策略
cifar10的标签就是从0到9十个标签,这里可以采用soft-label的策略,比如有些物体既像飞机又像汽车,那么就可以采用软的策略,来对标签进行预处理。

*   更好的loss设计,比如:采用分类+回归smooth-l1 loss等
另外可以采用更好的loss,这里采用交叉熵损失来完成图像分类的任务,另外大家也可以考虑结合回归的loss,来进行一个多个loss的约束。

*   不同的优化器、参数初始化方法等

发表回复

您的电子邮箱地址不会被公开。