import os
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import matplotlib as mpl
import helper
import pickle
import tensorflow as tf
import random
# 设置字符集，防止中文乱码
mpl.rcParams['font.sans-serif'] = [u'simHei']
mpl.rcParams['axes.unicode_minus'] = False
# 0、定义模型超参数。
learning_rate = 0.01 #学习率，梯度下降时，走的步长
batch_size = 256 #批量大小，将数据集分为好几批，一批批的输入神经网络中，每一批256条数据，一批批的执行梯度下降
keep_probability = 0.7 #dropout流程的保留比例，比如某一隐藏层神经节点参与运算时，使其百分之70为0
image_shape = [32, 32, 3] # 输入图片的尺寸 [32, 32, 3]
n_classes = 10 #数据集的类别数量
epochs = 2000 #训练过程中，所有数据将被前向传播反向传播更新轮多少次，轮的次数越多，模型越准确，但容易过拟合，比如：
# 训练集有1000个样本，batchsize(批量大小)=10，那么： 训练完整个样本集需要： 100次iteration(迭代次数)，1次epoch。
every_save_model = 2 # 每多少个epoch保存1次模型
'''
神经网络中常用的超参数
1. 学习率 η，2. 正则化参数 λ，3. 神经网络的层数 L，4. 每一个隐层中神经元的个数 j，5. 学习的回合数Epochs，6. 小批量数据 minibatch 的大小，7. 输出神经元的编码方式，8. 代价函数的选择，9. 权重初始化的方法，10. 神经元激活函数的种类，11.参加训练模型数据的规模
'''
"""
网络结构图。
input_x [-1, 32, 32, 3] 输入层，意为输入图片数据是32*32*3的尺寸，长、宽与通道数，-1意为bantch_size(批量)大小，此处设置为自动
w1 [5, 5, 3, 32] 权重，意为5*5*3的卷积核，32个，意为提取32张特征图，即32个特征
conv1 [-1, 32, 32, 32] 卷积层一，经过input_x与滤波器w1进行卷积运算后，得到：批量大小自动，长、宽、通道数为32*32*32的尺寸
池化1(步幅为2) [-1, 32/2, 32/2, 32] 池化层一：压缩数据，缩小图像，减小参数的数量和计算，意为，批量大小自动，执行步幅为2的平均池化或最 大池化，此步完成后得到的是16*16*32尺寸的数据
w2 [5, 5, 32, 128] 权重，意为5*5*32的卷积核，128个，卷积核数量通常都是上一次卷积核数量的倍数增加，意为提取128张特征图，即 128个特征
conv2 [-1, 16, 16, 128] 卷积层二，经过池化一后的数据与滤波器w2进行卷积运算后，得到：批量大小自动，长、宽、通道数为16*16*128的 尺寸，此次卷积相当于在第一次卷积提取出的特征的基础上，将第一次提取出来的特征的一些特征组合也提取出 来，相较于第一次卷积结果，因为随着网络的加深，feature map的长宽尺寸缩小(池化)，本卷积层的每个map提 取的特征越具有代表性（精华部分），所以后一层卷积层需要增加feature map的数量，才能更充分的提取出前一层 的特征，一般是成倍增加
池化2(步幅为2) [-1, 16/2, 16/2, 128]
拉平层 [N, 8, 8, 128] --> [N, 8*8*128]
FC1(权重) [8*8*128, 1024]
logits(权重) [1024, 10]
预测概率值 -----> 使用softmax激活
"""
#vgg16，resnet50这种层数的计算：层数只包含有参数的层，像池化层啊，relu激活层啊，loss层啊这些，都不计数
# 构建模型图 1、创建变量
graph = tf.Graph() #complete
with graph.as_default():
weights = {
'conv1': tf.get_variable('w1', shape=[5, 5, 3, 32], initializer=tf.truncated_normal_initializer(stddev=0.1)),
# tf.truncated_normal_initializer从截断的正态分布中输出随机值。生成的值服从具有指定平均值和标准偏差的正态分布，如果生成的值大于平均值2 个标准偏差的值则丢弃重新选择。
'conv2': tf.get_variable('w2', shape=[5, 5, 32, 128], initializer=tf.truncated_normal_initializer(stddev=0.1)),
'fc1': tf.get_variable('w3', shape=[8*8*128, 1024], initializer=tf.truncated_normal_initializer(stddev=0.1)),
'fc2': tf.get_variable('w4', shape=[1024, n_classes], initializer=tf.truncated_normal_initializer(stddev=0.1))
}
biases = {
'conv1': tf.get_variable('b1', shape=[32], initializer=tf.zeros_initializer()),
#tf.zeros_initializer 全0初始化
'conv2': tf.get_variable('b2', shape=[128], initializer=tf.zeros_initializer()),
'fc1': tf.get_variable('b3', shape=[1024], initializer=tf.zeros_initializer()),
'fc2': tf.get_variable('b4', shape=[n_classes], initializer=tf.zeros_initializer())
}
cifar10_dataset_folder_path = '../datas/cifar-10-batches-py'
if os.path.exists(cifar10_dataset_folder_path):
#os.path.exists 判断括号里的文件是否存在的意思，括号内的可以是文件路径。存在输出Ture,不存在输出False
print('yes')
def explore_data(): #探索一下数据，第五批次中第1001个样本的信息
batch_id = 5 #批次编号
sample_id = 1001 #样本编号
nums = helper.display_stats(cifar10_dataset_folder_path, batch_id, sample_id)
# epochs = nums // batch_id
def normalize(images,training=True): #complete
"""
归一化图片数据。将其缩放到(0,1)之间
:param images: 图片数据，图片的shape =[32, 32, 3]
:return: 归一化以后的numpy的数据
"""
return tf.layers.batch_normalization(images, training=True)
#tf.layers下封装了一些函数，其中包括此函数，批归一化的函数，参数很多不一一列举，，return的这两个参数分别是输入的图片，是否参与模型的训练，此处为参与，注意，当模型训练好后，用在验证数据上时，不再归一化，所以测试数据时，应为False.
def one_hot_encode(x): #complete
"""
对输入的列表（真实类别标签），转换为one-hot形式
:param x: 标签的list。
:return: one-hot编码后的结果，是一个numpy数组。
"""
return np.eye(10)[x.reshape(-1)].T #np.eye()意为生成多少行多少列的单位矩阵，因为one_hot编码，即是哪个类别，则第几位为1，其他几位都为0
#x.reshape(-1)将标签构成的数组x横向平铺成0123456789,
def preprocess_data_and_save():
# 预处理训练，验证、测试数据集。
helper.preprocess_and_save_data(cifar10_dataset_folder_path, normalize, one_hot_encode)
# todo 检查点。若预处理数据已经完成，并保存到本地磁盘，那么每次可以从这里开始运行（之前的代码不用再执行了）
valid_features, valid_labels = pickle.load(
open('../datas/cifar10/preprocess_validation.p', mode='rb'))
# print(len(valid_features))
#pickle我翻译为腌咸菜模块，作用是把python运行中得到的一些列表字典之类永久保存下来，其有两个方法，dump与load,dump(obj(对象), file(文件夹), [protocol可以为012,0是文本形式，1是老二进制，2是新二进制])，protocol意为协议
# load(文件夹)，保存为python文件到文件夹中
#open函数 打开一个文件，如果不存在则创建。rb是以二进制读模式打开
# load(文件夹)，保存为python文件到文件夹中
def cnn_net_input(image_shape, n_classes):
"""
定义 input_x, input_y ,keep_prob等占位符。
:param image_shape: 最原始的输入图片的尺寸
:param n_classes: 类别数量。
:return:
"""
input_x = tf.placeholder(tf.float32, [None, image_shape[0], image_shape[1], image_shape[2]], name='input_x')
#创建占位符，参数依然是 批量大小，长、宽、通道数
input_y = tf.placeholder(tf.float32, [None, n_classes], name='input_y')
change_learning_rate = tf.placeholder(tf.float32, shape=None, name='change_learning_rate')
#学习率 无形状，标量
keep_probab = tf.placeholder(tf.float32, shape=None, name='keep_probab')
#保留比例
return input_x, input_y, change_learning_rate, keep_probab
def conv2d(input_tensor, filter_w, filter_b, strides=[1, 1, 1, 1]): #complete
"""
实现 1、卷积 + 2、偏置项相加 + 3、激活
:param x:
:param filter_w:
:param filter_b:
:param strides:
:return:
"""
# 1、卷积
conv = tf.nn.conv2d(
input=input_tensor, filter=filter_w, strides=strides, padding='SAME'
)
#tf.nn是tensorflow一个内置的十分丰富的函数大集锦，其中就包括了conv2d这个函数，计算给定4-D输入和滤波器张量的2-D卷积
#以上四个参数分别是;输入数据；滤波器；strides=[1, 1, 1, 1]是设置的滤波器的步长，steides四个1分别是N H W C，样本数，高度，宽度，通道数，第 一个和最后一个1是官方规定的必须是1，第二个和第三个分别是水平步长和垂直方向步长；当输入数据的 矩阵不够卷积核扫描时是否在四周填充0，使输 入图片和卷积后的图片长宽尺寸一样。若是设置valid(合理的)则不会填充，从而有可能形状变小
# 2、偏置项相加
conv = tf.nn.bias_add(conv, filter_b)
#将偏置项bias的向量加到value的矩阵上，是向量与矩阵的每一行进行相加，得到的结果和value矩阵大小相同
# 3、激活
conv = tf.nn.relu(conv)
return conv
def maxpool2d(input_tensor, k=2): #complete
kernel_size = [1, k, k, 1]
#池化也是用滤波器来达到计算目的的，也叫池化核，此为池化核大小，四个参数同上面的strides,N,H,W C 样本数，高，宽，通道数
strides = [1, k, k, 1]
#池化步幅为2，原矩阵会缩小一半，步幅为1 时原矩阵尺寸不变
maxpool_out = tf.nn.max_pool(
value=input_tensor, ksize=kernel_size, strides=strides, padding='SAME'
)
#最大池化操作，padding=same为矩阵周边填充0
return maxpool_out
def flatten(input_tensor): #complete
"""
flatten层，实现特征图 维度从 4-D 重塑到 2-D形状 [Batch_size, 列维度]
:param input:
:return:
"""
shape = input_tensor.get_shape() # [N, 8, 8, 128]
flatten_shape = shape[1] * shape[2] * shape[3]
flatted = tf.reshape(input_tensor, shape=[-1, flatten_shape])
#tf.reshape 改变指定数据的形状
return flatted
def fully_connect(input_tensor, weights, biases, activation=tf.nn.relu): #complete
"""
实现全连接 或者 输出层。
:param input_tensor:
:param num_outputs: 输出的隐藏层节点数量。
:return:
"""
#卷积后要激活，池化不要激活，最后一步是全连接时得到output,要激活才能得到预测值
fc = tf.matmul(input_tensor, weights) + biases
if activation:
fc = activation(fc)
return fc
else:
# 这里是为了返回最终输出的logits。
return fc
def model_net(input_x, weights, biases, keep_prob, istrain): #complete
"""
构建模型
:param input_x: 原始图片的占位符
:param keep_prob: 定义的keep_prob的占位符。
:return: logits
"""
"""
网络结构图。
input_x [-1, 32, 32, 3]
w1 [5, 5, 3, 32]
conv1 [-1, 32, 32, 32]
池化1(步幅为2) [-1, 32/2, 32/2, 32]
w2 [5, 5, 32, 128]
conv2 [-1, 16, 16, 128]
池化2(步幅为2) [-1, 16/2, 16/2, 128]
拉平层 [N, 8, 8, 128] --> [N, 8*8*128]
FC1(权重) [8*8*128, 1024]
logits(权重) [1024, 10]
预测概率值 -----> 使用softmax激活
"""
# conv1--dropout(可选)--池化1--conv2--dropout(可选)--池化2--拉平层--全连接层*N--输出层 得到logits
with tf.variable_scope('Network'):
# 卷积1 [N, 32, 32, 3] --> [N, 32, 32, 32]
conv1 = conv2d(
input_tensor=input_x, filter_w=weights['conv1'], filter_b=biases['conv1'])
conv1 = tf.nn.dropout(conv1, keep_prob=keep_probability)
if istrain:
conv1 = normalize(conv1)
# 池化1 [N, 32, 32, 32] -->[N, 16, 16, 32]
pool1 = maxpool2d(conv1)
# 卷积2 [N, 16, 16, 32] --> [N, 16, 16, 128]
conv2 = conv2d(
input_tensor=pool1, filter_w=weights['conv2'], filter_b=biases['conv2'])
conv2 = tf.nn.dropout(conv2, keep_prob=keep_probability)
if istrain:
conv2 = normalize(conv2)
# 池化2 [N, 16, 16, 128] -->[N, 8, 8, 128]
pool2 = maxpool2d(conv2)
# 拉平层 [N, 8, 8, 128] ---> [N, 8*8*128]
shape = pool2.get_shape() # [N, 8, 8, 128]
flatten_shape = shape[1] * shape[2] * shape[3]
flatted = tf.reshape(pool2, shape=[-1, flatten_shape])
# 全连接层1 [N, 8*8*128] ---> [N, 1024]
fc1 = fully_connect(
input_tensor=flatted, weights=weights['fc1'], biases=biases['fc1'])
fc1 = tf.nn.dropout(fc1, keep_prob=keep_prob)
# 全连接层2（输出层） [N, 1024] ---> [N, 10]
logits = fully_connect(
input_tensor=fc1, weights=weights['fc2'], biases=biases['fc2'], activation=None
)
return logits
# todo 自己定义两个执行会话环节需要使用的辅助函数。
def train_session(sess, train_opt, input_x, input_y, batch_x, batch_y, keep_prob, keep_probability, change_learning_rate, learning_rate):
"""
执行的跑 模型优化器的函数
:param sess: 会话的实例对象
:param train_opt: 优化器对象
:param keep_probability: 实数，保留概率
:param batch_x: 当前的批量的images数据
:param batch_y: 当前批量的标签数据。
:return: 仅仅是执行优化器，无需返回值。
"""
feed = {input_x: batch_x, input_y: batch_y, keep_prob: keep_probability, change_learning_rate: learning_rate}
sess.run(train_opt, feed_dict=feed) # 执行模型训练
def print_stats(sess, loss, accuracy, input_x, input_y, batch_x, batch_y, keep_probab, keep_probability, change_learning_rate, learning_rate):
"""
使用sess跑loss和 Accuracy，并打印出来
:param sess: 会话的实例对象
:param batch_x: 当前的批量的images数据
:param batch_y: 当前批量的标签数据。
:param loss: 图中定义的loss tensor对象
:param accuracy: 图中定义的accuracy tensor对象
:return: 仅仅是打印模型，无需返回值。
"""
feed = {input_x: batch_x, input_y: batch_y, keep_probab: keep_probability, change_learning_rate: learning_rate}
change_loss, change_acc = sess.run(
[loss, accuracy], feed)
loss_ = change_loss
accuracy_ = change_acc
print('Loss:{:.5f} - Valid Accuracy:{:.4f}'.format(loss_, accuracy_))
def create_file_path(path): #complete
"""
创建文件夹路径函数
"""
if not os.path.exists(path):
os.makedirs(path)
print('成功创建路径:{}'.format(path))
# ____________________________________________________________________________________________________
def train_single_batch():
"""
先跑 preprocess-batch-1 这个训练数据集，确认模型ok之后，跑所有的数据。
:return:
"""
tf.reset_default_graph()
my_graph = tf.Graph()
# 一、建图
with my_graph.as_default():
# 1、创建占位符（输入图片，输入的标签，dropout）
input_x, input_y,change_learning_rate, keep_prob = cnn_net_input(image_shape, n_classes)
# 2、构建cnn图（传入输入图片，获得logits）
logits = model_net(input_x, weights, biases, keep_probab, True)
# 3、构建损失函数
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(
logits=logits, labels=input_y
))
# 4、构建优化器。
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops): #保证train_op在update_ops执行之后再执行。
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_opt = optimizer.minimize(loss)
# 5、计算准确率
correct_pred = tf.equal(tf.argmax(logits, axis=1), tf.argmax(input_y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
# 二、构建会话
with tf.Session() as sess:
# 1、初始化全局变量
sess.run(tf.global_variables_initializer())
# 2、构建迭代的循环
for epoch in range(epochs):
batch_i = 1
# 3、构建批量数据的循环
# 3、构建批量数据的循环
for batch_x, batch_y in helper.load_preprocess_training_batch(batch_i, batch_size):
# 4、跑train_opt
train_session(sess, train_opt, input_x, input_y, batch_x, batch_y, keep_probab,
keep_probability, change_learning_rate, learning_rate)
print('Epoch {:>2}, CIFAR-10 Batch:{}'.format(epoch + 1, batch_i), end='')
# 5、跑 模型损失和 准确率，并打印出来。
print_stats(sess, loss, accuracy, input_x, input_y, batch_x, batch_y, keep_probab,
keep_probability, change_learning_rate, learning_rate)
# # 执行模型持久化的。
# if epoch % every_save_model == 0:
# save_file = '_{}_model.ckpt'.format(epoch)
# save_file = os.path.join(save_path, save_file)
# saver.save(sess, save_path=save_file)
# print('Model saved to {}'.format(save_file))
# ________________________________________________________________________________________________________
def train_all_batch():
"""
跑所有的数据。
"""
# 一、建图
with graph.as_default():
# 1、创建占位符（输入图片，输入的标签，dropout）
input_x, input_y, change_learning_rate, keep_probab = cnn_net_input(image_shape, n_classes)
# 2、构建cnn图（传入输入图片，获得logits）
logits = model_net(input_x, weights, biases, keep_probab, True)
# 3、构建损失函数
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits,
labels=input_y))
# 4、构建优化器。
optimizer = tf.train.AdamOptimizer(learning_rate = change_learning_rate)
train_opt = optimizer.minimize(loss)
# 5、计算准确率
correct_pred = tf.equal(tf.argmax(logits, axis=1), tf.argmax(input_y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
# 6、构建持久化模型的对象 并创建 持久化文件保存的路径
saver = tf.train.Saver(max_to_keep=2)
save_path = './models/checkpoints'
create_file_path(save_path)
# 二、构建会话
with tf.Session() as sess:
# 1、初始化全局变量
ckpt = tf.train.get_checkpoint_state(save_path)
if ckpt is not None:
saver.restore(sess, ckpt.model_checkpoint_path)
saver.recover_last_checkpoints(ckpt.all_model_checkpoint_paths)
print('从持久化文件中恢复模型')
else:
sess.run(tf.global_variables_initializer())
print('没有持久化文件，从头开始训练!')
# 2、构建迭代的循环
print("epochs: {}".format(epochs))
for epoch in range(epochs):
# 多加一个循环，遍历所有的训练数据的batch
n_batches = 5
for batch_i in range(1, n_batches+1):
# 3、构建批量数据的循环
for batch_x, batch_y in helper.load_preprocess_training_batch(batch_i, batch_size):
# 4、跑train_opt
train_session(sess, train_opt, input_x, input_y, batch_x, batch_y, keep_probab,
keep_probability, change_learning_rate, learning_rate)
print('Epoch {:>2}, CIFAR-10 Batch:{}'.format(epoch+1, batch_i), end='')
# 5、跑 模型损失和 准确率，并打印出来。
print_stats(sess, loss, accuracy, input_x, input_y, batch_x, batch_y, keep_probab,
keep_probability, change_learning_rate, learning_rate)
# 执行模型持久化的。
if epoch % every_save_model == 0:
save_file = '_{}_model.ckpt'.format(epoch)
save_file = os.path.join(save_path, save_file)
saver.save(sess, save_path=save_file)
print('Model saved to {}'.format(save_file))
def gotest_model():
"""
调用持久化文件跑测试数据集的数据。（要求准确率在60%以上）
"""
tf.reset_default_graph()
test_features, test_labels = pickle.load(
open('../datas/cifar10/preprocess_test.p', mode='rb')
)
# 一、建图
with graph.as_default():
# 1、创建占位符（输入图片，输入的标签，dropout）
input_x, input_y, change_learning_rate, keep_probab = cnn_net_input(image_shape, n_classes)
# 2、构建cnn图（传入输入图片，获得logits）
logits = model_net(input_x, weights, biases, keep_probab, True)
# 3、构建损失函数
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits,
labels=input_y))
# 4、构建优化器。
optimizer = tf.train.AdamOptimizer(learning_rate=change_learning_rate)
train_opt = optimizer.minimize(loss)
# 5、计算准确率
correct_pred = tf.equal(tf.argmax(logits, axis=1), tf.argmax(input_y, 1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
# 6、构建持久化模型的对象 并创建 持久化文件保存的路径
saver = tf.train.Saver(max_to_keep=2)
save_path = './models/checkpoints'
# 二、构建会话
with tf.Session() as sess:
# 2、获取持久化的信息对象
ckpt = tf.train.get_checkpoint_state(save_path)
if ckpt is not None:
saver.restore(sess, ckpt.model_checkpoint_path)
saver.recover_last_checkpoints(ckpt.all_model_checkpoint_paths)
print('从持久化文件中恢复模型')
else:
sess.run(tf.global_variables_initializer())
print('没有持久化文件，从头开始训练!')
# 2、保存每个批次数据的准确率，再求平均值。
test_acc_total = []
# 3、构建迭代的循环
for test_batch_x, test_batch_y in helper.batch_features_labels(test_features, test_labels, batch_size):
test_dict = {input_x: test_batch_x,
input_y: test_batch_y,
keep_probab: 1.0}
test_batch_acc = sess.run(accuracy, test_dict)
test_acc_total.append(test_batch_acc)
print('Test Accuracy:{:.5f}'.format(np.mean(test_acc_total)))
if np.mean(test_acc_total) > 0.6:
print('恭喜你，通过了Cifar10项目！你已经掌握了CNN网络的基础知识!')
if __name__=='__main__':
# explore_data()
# train_all_batch()
gotest_model()
# train_single_batch()