VGG16+CIFAR10分类的实现

import numpy as np
import tensorflow as tf
import os
import pickle
from keras.utils import np_utils

CIFAR_PATH = r’D:\python\MNIST_data\cifar-10-batches-py’

def load_data(file):
with open(file, ‘rb’) as f:
data = pickle.load(f, encoding=‘bytes’)
return data[b’data’], data[b’labels’]

def Cifar(filenames):
all_data = []
all_label = []
for file_name in filenames:
data, label = load_data(file_name)
all_data.append(data)
all_label.append(label)
all_data = np.vstack(all_data).astype(np.float32)
all_label = np.hstack(all_label)
#上面两行只是为了获取numpy类型的数组也可以向下面这么写：
/*
all_data = np.array(all_data).reshape([-1, 3072]).astype(np.float32)
all_label = np.array(all_label).reshape([len(all_data), -1])
*/
all_data /= 255
return all_data, all_label

通过索引打乱训练集

/*
关于这个函数，我测试的时候一使用精确度就和随机猜一样，我参考的另一个博主写的方法就没有问题
def _shffle_data( ):
# np.random.permutation() 从 0 到 参数,随机打乱
p = np.random.permutation( self._num_examples )
# 保存 已经打乱 顺序的数据
self._data = self._data[p]
self._labels = self._labels[p]
原文链接：https://blog.csdn.net/missyougoon/article/details/82586643
*/
def shuffle_data(images, labels):
index = [i for i in range(len(labels))]
np.random.shuffle(index)
train_img = images[index]
train_lab = labels[index]
return train_img, train_lab

n_classes = 10

获取文件下所有的符合要求的文件

train_filename = [os.path.join(CIFAR_PATH, ‘data_batch_%d’ % i) for i in range(1, 6)]

测试文件

test_filename = [os.path.join(CIFAR_PATH, ‘test_batch’)]

train_data, train_label = Cifar(train_filename)
train_label = np_utils.to_categorical(train_label, n_classes)
test_data, test_label = Cifar(test_filename)
test_label = np_utils.to_categorical(test_label, n_classes)
print(train_data.shape[1], test_label.shape)

搭建神经网络

x = tf.placeholder(dtype=tf.float32, shape=([None, train_data.shape[1]]))
y = tf.placeholder(dtype=tf.int64, shape=([None,10]))

input_x = tf.reshape(x, [-1, 3, 32, 32])
images = tf.transpose(input_x, perm=[0, 2, 3, 1])

定义卷积层

conv1_1 = tf.layers.conv2d(inputs=images, filters=32, kernel_size=(3, 3), strides=1, padding=‘same’,
activation=tf.nn.relu)
conv1_2 = tf.layers.conv2d(conv1_1,
32, # 输出的通道数(也就是卷积核的数量)
(3, 3), # 卷积核大小
padding=‘same’,
activation=tf.nn.relu)

池化层 图像输出为: 16 * 16

pooling1 = tf.layers.max_pooling2d(conv1_2,
(2, 2), # 核大小
(2, 2), # 步长
)
conv2_1 = tf.layers.conv2d(pooling1,
32, # 输出的通道数
(3, 3), # 卷积核大小
padding=‘same’,
activation=tf.nn.relu,
)
conv2_2 = tf.layers.conv2d(conv2_1,
32, # 输出的通道数
(3, 3), # 卷积核大小
padding=‘same’,
activation=tf.nn.relu,
)

池化层 图像输出为 8 * 8

pooling2 = tf.layers.max_pooling2d(conv2_2,
(2, 2), # 核大小
(2, 2), # 步长
)
conv3_1 = tf.layers.conv2d(pooling2,
32, # 输出的通道数
(3, 3), # 卷积核大小
padding=‘same’,
activation=tf.nn.relu,
)
conv3_2 = tf.layers.conv2d(conv3_1,
32, # 输出的通道数
(3, 3), # 卷积核大小
padding=‘same’,
activation=tf.nn.relu,
)

池化层 输出为 4 * 4 * 32

pooling3 = tf.layers.max_pooling2d(conv3_2,
(2, 2), # 核大小
(2, 2), # 步长
)

展平

flatten = tf.contrib.layers.flatten(pooling3)
y_out = tf.layers.dense(flatten, 10)

损失函数

loss = tf.losses.softmax_cross_entropy(onehot_labels=y, logits=y_out)

求准确率

correct_prediction = tf.equal(tf.argmax(y_out, 1), tf.argmax(y, 1))
acc = tf.reduce_mean(tf.cast(correct_prediction, dtype=tf.float32))

定义优化器

train_opt = tf.train.AdamOptimizer(0.001).minimize(loss)

训练模型

epoch = 150
batch_size = 20

创建会话

with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for i in range(epoch + 1):
# train_images, train_label = shuffle_data(train_data, train_label)
#这里调用另一个打乱数据集的函数好一写
for k in range(0, len(train_label), batch_size):
image_batch = train_images[k:k + batch_size]
label_batch = train_label[k:k + batch_size]
sess.run([train_opt], feed_dict={x: image_batch, y: label_batch})
test_acc = sess.run(acc, feed_dict={x: test_data, y: test_label})
print(“第” + str(i) + “轮测试” + “精度为:” + str(test_acc))
#测试结果：精度不高，怕是应该调参（我又不知道如何调参）
第68轮测试精度为:0.6965
第69轮测试精度为:0.691
第70轮测试精度为:0.6965
第71轮测试精度为:0.6966
第72轮测试精度为:0.6911
第73轮测试精度为:0.7012
第74轮测试精度为:0.7021
第75轮测试精度为:0.6868
第76轮测试精度为:0.6979
第77轮测试精度为:0.6822
第78轮测试精度为:0.6837
第79轮测试精度为:0.6923