[深度学习]基于TensorFlow的基本深度学习模型

cifar10训练数据集下载

链接：https://pan.baidu.com/s/1Qlp2G5xlECM6dyvUivWnFg
提取码：s32t

代码解析

前置配置

引入tensorflow库，和其他辅助库文件。安装方式为pip3 install tensorflow numpy pickle。详细过程不在这里描述。
在这里，训练和测试数据集文件放在该脚本的父文件夹中，因此按照实际情况来对CIFAR_DIR赋值，该参数将在后续过程中被引用。

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import os
import pickle
import numpy as np

CIFAR_DIR = "./../cifar-10-batches-py"
print(os.listdir(CIFAR_DIR))

整理图片训练集和测试集

数据集解析函数的介绍

在训练模型之前，最基础的是要分析数据集的结构，以及解析的方法。
在训练脚本中定义一个辅助函数。该函数的作用是，将传递过来的参数中的文件打开，并以字节的形式储存在data变量中。解析后的数据表中将存在两个子数据集，一个名为data，另一个名为label，data即单个图片信息本身，而label则是该数据的类别，比如一辆车。

def load_data(filename):
    """read data from data file."""
    with open(filename, 'rb') as f:
        data = pickle.load(f, encoding='bytes')
        return data[b'data'], data[b'labels']

下面我们用实际数据跑一下该函数，使数据可视化，看看数据究竟是以怎样的形式得到处理的。
实现看一下这个训练集的文件组织形式。首先是5个data_batch，即5个数据组，还有一个test_batch用于对训练好的神经元进行测试。我们拿data_batch_1和test_batch做个实验，将其中的一部分数据解析出来。

下面是一段测试脚本，来读取data_batch_1中的第一个data和第一个label。
同样，我们还需要读取test_batch中的第一个data和第一个label。

import os
import pickle
import numpy as np

CIFAR_DIR = "./cifar-10-batches-py"
print(os.listdir(CIFAR_DIR))

def load_data(filename):
    """read data from data file."""
    with open(filename, 'rb') as f:
        data = pickle.load(f, encoding='bytes')
        print(data)#将读取到的生文件直接显示出来，事实证明这里面改是个超大的字典
        return data[b'data'], data[b'labels']

train_filename = os.path.join(CIFAR_DIR, 'data_batch_1')
test_filename = os.path.join(CIFAR_DIR, 'test_batch')

train_data, train_labels = load_data(train_filename)
test_data, test_labels = load_data(test_filename)

print('data_batch_1 的数据个数：{}'.format(len(train_data)))
print('data_batch_1 的标签个数：{}'.format(len(train_labels)))
print('-'*30)
print('test_batch 的数据个数：{}'.format(len(test_data)))
print('test_batch 的标签个数：{}'.format(len(test_labels)))
print('-'*30)
print('train_batch_1 图片的像素：{}'.format(len(train_data[0])))
print('test_batch 图片的像素：{}'.format(len(test_data[0])))
print('-'*30)
print('第一个训练集数据及其标签')
print(train_labels[0])
print(train_data[0])
print('-'*30)
print('第一个测试集数据及其标签')
print(test_labels[0])
print(test_data[0])

首先来看一下没有处理的生数据集，它是一个字典，里面包含该组的信息，labels，data和每一个文件的名字。data中的每一个列表里面其实都代表了一个像素点的只，代表不同的颜色，这个列表中的所有像素点组成了一个小图片，例如第一个data中的信息如列表中所示[ 59, 43, 50, …, 140, 84, 72]。我们看看这个列表有多长。

接下来我们统计出这个数据集的具体信息，打印信息如下：

所以可以看到每个batch中都有10000个图片，每个图片的像素数量为3072=1024*3，这里需要澄清，因为图片都是由三原色RGB组成，因此图片实际由1024（32 x 32）个像素点组成，3倍的数据量是由于颜色信息造成的。

对数据集的精加工

代码的作用写在了每一行后面的注释里
这个类主要的功能是，将所有文件中的数据合入到同一对儿列表中，
还提供了_shuffle_data函数，如果有必要的话，可以启用该函数，在不破坏图片数据和对应标签的对应关系的前提下，将所有的列表内容顺序打乱，进而提高训练的有效性。
最后，这个类还提供了一个函数next_batch，该函数允许训练或者测试的过程中以特定的步进值进行训练然后执行测试，这样我们就可以看到阶段性的测试结果。

# tensorflow.Dataset.
class CifarData:
    def __init__(self, filenames, need_shuffle):#初始化函数，需要一个文件名称，和一个是否需要打乱顺序的置位符（选1则打乱）
        all_data = []#将所有图片数据放在这个列表中
        all_labels = []#将所有图片对应的标签放在这个列表中
        for filename in filenames:#例如，训练数据集中有5个文件，则依次循环这5个文件
            data, labels = load_data(filename)#在这里引用了上一节提供的文件加载函数，返回一个数据集 和 一个标签集
            all_data.append(data)#将所有5个文件中的图片数据添加到all_data列表中
            all_labels.append(labels)#将所有5个文件中的标签数据添加到all_labels列表中
        self._data = np.vstack(all_data)
        self._data = self._data / 127.5 - 1
        self._labels = np.hstack(all_labels)
        print(self._data.shape)
        print(self._labels.shape)
        
        self._num_examples = self._data.shape[0]#data shape是(50000,3702),所以self._data.shape[0]就代表50000，
        										#也就是说，_num_examples代表所有训练数据的个数
        self._need_shuffle = need_shuffle#如果置1，则启动打乱程序：_shuffle_data
        self._indicator = 0#这个值的作用是一个游标，每次执行完函数next_batch后，这个值就更新为当前所在的self._data列表的位置
        				#这很重要，因为我们需要判断50000个数据是否都训练到了，如果想再学习一轮以加固训练效果，则需要该游标进行判断
        				#具体的执行过程需要参考 next_batch函数 以及 训练和测试 章节
        if self._need_shuffle:
            self._shuffle_data()#这里需要注意，我们要对实例化后的数据集进行_shuffle_data
            
    def _shuffle_data(self):
        # [0,1,2,3,4,5] -> [5,3,2,4,0,1]
        p = np.random.permutation(self._num_examples)
        self._data = self._data[p]
        self._labels = self._labels[p]
    
    def next_batch(self, batch_size):
        """return batch_size examples as a batch."""
        end_indicator = self._indicator + batch_size#该示例的batch_size为20，也就是每次训练取列表中的20个图片数据，
        											#然而我们有50000个图片，这样的重复需要50000/20次，而每次完成训练后，把本实例中的self._indicator更新为本次训练的end_indicator 
		"""
		如果没啥幺蛾子，下面两段IF是不执行的。需要执行的话有两种可能：
		1. 训练数据集用完了，判断是否需要第二轮，或更多轮的训练
		2. 初始状态下就异常，八成是batch_size设置得太大
		剩余的数据不够batch_size个了，则直接放弃剩余数据，打乱顺序继续第二轮训练
		"""
        if end_indicator > self._num_examples:#如果本次训练end_indicator数值超过50000了，则
        									#说明我们学完了所有50000个图片，需要进行第二轮的学习
            if self._need_shuffle:
                self._shuffle_data()#第二轮学习为了有效，我们再次打乱50000个图片数据
                self._indicator = 0#游标再次置0，这样我们就可以愉快地开始第二轮训练了
                end_indicator = batch_size
            else:#如果当时初始化没有要求打乱，则证明我们不需要第二轮学习。这时中断测试，并抛出异常提示没有更多的训练数据了。
                raise Exception("have no more examples")#不用再看了，训练结束了，放学！
        if end_indicator > self._num_examples:#上一个IF语句中重置了end_indicator为batch_size值，
        									#如果此时还是比_num_examples大的话，则证明这个batch_size只是单纯地设置得太大了。
            raise Exception("batch size is larger than all examples")#抛出异常，中断测试，回去修改batch_size去...
        batch_data = self._data[self._indicator: end_indicator]#获取本次需要的20个图片数据，每次循环都会往后移动20个
        batch_labels = self._labels[self._indicator: end_indicator]#获取本次需要的20个标签数据，每次循环都会往后移动20个
        self._indicator = end_indicator#循环由外部引用来进行，每完成一次next_batch就更新一下self._indicator
        return batch_data, batch_labels#当然这个函数执行完就要交货了，也就是需要用于训练的20个数据，上面的一堆步骤都是前期审核和位置记录

train_filenames = [os.path.join(CIFAR_DIR, 'data_batch_%d' % i) for i in range(1, 6)]
test_filenames = [os.path.join(CIFAR_DIR, 'test_batch')]

train_data = CifarData(train_filenames, True)
test_data = CifarData(test_filenames, False)

创建神经元

x = tf.placeholder(tf.float32, [None, 3072])
# [None], eg: [0,5,6,3]
y = tf.placeholder(tf.int64, [None])

# (3072, 10)
w = tf.get_variable('w', [x.get_shape()[-1], 10],
                   initializer=tf.random_normal_initializer(0, 1))
# (10, )
b = tf.get_variable('b', [10],
                   initializer=tf.constant_initializer(0.0))

# [None, 3072] * [3072, 10] = [None, 10]
y_ = tf.matmul(x, w) + b

# mean square loss
"""
# course: 1 + e^x
# api: e^x / sum(e^x)
# [[0.01, 0.9, ..., 0.03], []]
p_y = tf.nn.softmax(y_)
# 5 -> [0,0,0,0,0,1,0,0,0,0]
y_one_hot = tf.one_hot(y, 10, dtype=tf.float32)
loss = tf.reduce_mean(tf.square(y_one_hot - p_y))
"""

loss = tf.losses.sparse_softmax_cross_entropy(labels=y, logits=y_)
# y_ -> sofmax
# y -> one_hot
# loss = ylogy_



# indices
predict = tf.argmax(y_, 1)
# [1,0,1,1,1,0,0,0]
correct_prediction = tf.equal(predict, y)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float64))

with tf.name_scope('train_op'):
    train_op = tf.train.AdamOptimizer(1e-3).minimize(loss)

训练和测试

init = tf.global_variables_initializer()
batch_size = 20 #每一批次训练数量
train_steps = 100000 #训练的次数
test_steps = 100 #测试的次数
#共执行100000轮训练，每次训练20张图片

with tf.Session() as sess: #进入TensorFlow的上下文环境
    sess.run(init) #执行会话初始化
    for i in range(train_steps):#开始训练，训练次数100,000次
        batch_data, batch_labels = train_data.next_batch(batch_size)
        # 由于train_data是一个CifarData的实例，因此包含next_batch方法
        # 该方法返回两个值，分别是图片本身，和图片的正确标签
        
        loss_val, acc_val, _ = sess.run(
            [loss, accuracy, train_op],
            feed_dict={
                x: batch_data,
                y: batch_labels})
        # 将创建神经元的相关参数传入会话启动函数
        # 同时将上一步的batch_data和batch_labels传入
        
        if (i+1) % 500 == 0:
            print('[Train] Step: %d, loss: %4.5f, acc: %4.5f' 
                  % (i+1, loss_val, acc_val)) 
                  #每执行500次batch训练后执行一次打印
        if (i+1) % 5000 == 0:
        # 每执行5000次训练，则进入一次测试环节
            test_data = CifarData(test_filenames, False)
            # 将实例化的CifarData引入，无打乱数据对的动作
            all_test_acc_val = [] #用于存储每次测试的成绩
            for j in range(test_steps): # 在当前状态下执行测试100次
                test_batch_data, test_batch_labels \
                    = test_data.next_batch(batch_size)
                    #test_data是一个CifarData的实例，因此拥有next_batch方法
                    #该实例返回图片和标签键值对，用于本轮测试
                    
                test_acc_val = sess.run(
                    [accuracy],
                    feed_dict = {
                        x: test_batch_data, 
                        y: test_batch_labels
                    })
                    #参数部分只传入准确度算法
                    #传入测试用数据
                    
                all_test_acc_val.append(test_acc_val)
                #将最近一次的测试成绩追加到列表中
            test_acc = np.mean(all_test_acc_val)#计算全部测试成绩的平均值
            print('[Test ] Step: %d, acc: %4.5f' % (i+1, test_acc))
            #将测试成绩打印出来

实验：训练与测试

训练测试结果如下：

[Train] Step: 500, loss: 1.58593, acc: 0.45000
[Train] Step: 1000, loss: 1.62919, acc: 0.35000
[Train] Step: 1500, loss: 1.50075, acc: 0.40000
[Train] Step: 2000, loss: 1.77732, acc: 0.50000
[Train] Step: 2500, loss: 1.48316, acc: 0.50000
[Train] Step: 3000, loss: 1.86442, acc: 0.20000
[Train] Step: 3500, loss: 1.60126, acc: 0.50000
[Train] Step: 4000, loss: 1.53028, acc: 0.35000
[Train] Step: 4500, loss: 1.50963, acc: 0.45000
[Train] Step: 5000, loss: 1.87891, acc: 0.40000
[Test ] Step: 5000, acc: 0.48350
[Train] Step: 5500, loss: 1.47629, acc: 0.50000
[Train] Step: 6000, loss: 1.50326, acc: 0.40000
[Train] Step: 6500, loss: 1.94290, acc: 0.40000
[Train] Step: 7000, loss: 1.52690, acc: 0.60000
[Train] Step: 7500, loss: 1.88528, acc: 0.45000
[Train] Step: 8000, loss: 1.48218, acc: 0.25000
[Train] Step: 8500, loss: 1.15569, acc: 0.60000
[Train] Step: 9000, loss: 1.41944, acc: 0.60000
[Train] Step: 9500, loss: 1.09230, acc: 0.50000
[Train] Step: 10000, loss: 1.20441, acc: 0.60000
[Test ] Step: 10000, acc: 0.49950
[Train] Step: 10500, loss: 1.50901, acc: 0.35000
[Train] Step: 11000, loss: 1.26781, acc: 0.70000
[Train] Step: 11500, loss: 1.56929, acc: 0.35000
[Train] Step: 12000, loss: 1.40768, acc: 0.50000
[Train] Step: 12500, loss: 1.29786, acc: 0.55000
[Train] Step: 13000, loss: 1.11843, acc: 0.50000
[Train] Step: 13500, loss: 1.52579, acc: 0.45000
[Train] Step: 14000, loss: 1.25250, acc: 0.45000
[Train] Step: 14500, loss: 1.45027, acc: 0.60000
[Train] Step: 15000, loss: 1.33762, acc: 0.50000
[Test ] Step: 15000, acc: 0.51500
...
...
[Train] Step: 85500, loss: 0.73292, acc: 0.70000
[Train] Step: 86000, loss: 0.86250, acc: 0.70000
[Train] Step: 86500, loss: 1.11111, acc: 0.70000
[Train] Step: 87000, loss: 0.96548, acc: 0.60000
[Train] Step: 87500, loss: 0.84424, acc: 0.75000
[Train] Step: 88000, loss: 0.44307, acc: 0.90000
[Train] Step: 88500, loss: 0.43235, acc: 0.75000
[Train] Step: 89000, loss: 0.27175, acc: 0.90000
[Train] Step: 89500, loss: 0.59743, acc: 0.75000
[Train] Step: 90000, loss: 0.71875, acc: 0.80000
[Test ] Step: 90000, acc: 0.50500
[Train] Step: 90500, loss: 0.70543, acc: 0.95000
[Train] Step: 91000, loss: 1.33814, acc: 0.5000
[Train] Step: 91500, loss: 0.86871, acc: 0.60000
[Train] Step: 92000, loss: 0.74334, acc: 0.75000
[Train] Step: 92500, loss: 0.33108, acc: 0.85000
[Train] Step: 93000, loss: 0.62105, acc: 0.80000
[Train] Step: 93500, loss: 0.51634, acc: 0.80000
[Train] Step: 94000, loss: 0.50421, acc: 0.90000
[Train] Step: 94500, loss: 0.66806, acc: 0.75000
[Train] Step: 95000, loss: 0.56096, acc: 0.75000
[Test ] Step: 95000, acc: 0.49600
[Train] Step: 95500, loss: 0.97452, acc: 0.55000
[Train] Step: 96000, loss: 0.61921, acc: 0.70000
[Train] Step: 96500, loss: 0.65663, acc: 0.75000
[Train] Step: 97000, loss: 0.72440, acc: 0.75000
[Train] Step: 97500, loss: 0.42541, acc: 0.90000
[Train] Step: 98000, loss: 1.06353, acc: 0.70000
[Train] Step: 98500, loss: 0.33118, acc: 0.85000
[Train] Step: 99000, loss: 0.63042, acc: 0.75000
[Train] Step: 99500, loss: 0.81720, acc: 0.75000
[Train] Step: 100000, loss: 0.67232, acc: 0.70000
[Test ] Step: 100000, acc: 0.50150

从结果中可以看到，训练结果打印达到100000/500=200次，测试次数为100000/5000=20次

最终的测试结果显示正确率达到0.50150，也就是说在看到图片后，该神经网络有一半的几率正确识别出图片中的内容，如果随机猜测，正确率为十分之一，虽然该基础模型的测试成绩不是很理想，但是总会比随机猜测的几率高一些，后续我们使用更有效的神经网络模型来做相同的测试，例如卷积神经网络。