CIFAR10分类算法记录

CIFAR-10共有60000张图片,共有10个分类,每个分类大概6000
张,训练集共有50000张图片,测试集共有10000张图片,训练集每个分类约有
5000张图片,测试集每个分类约有1000张图片,训练集分5个批次,每个批次约
有10000张图片,测试集只有一个批次,该批次有10000张图片

图片分类

import tensorflow as tf
import  problem_unittests as tests
import helper  #这是CIFAR10使用的帮助文件,见下
import numpy as np
import matplotlib.pyplot as plt #导入画笔

pickle模块是能够让我们直接在文件中存储几乎任何Python对象的高级工具

import pickle

探索数据集

cifar10_dataset_folder_path =\
    "./cifar-10-python/cifar-10-batches-py"
tests.test_folder_path(cifar10_dataset_folder_path)
batch_id = 2  #批次
sample_id = 20 #批次中样本id
helper.display_stats(cifar10_dataset_folder_path,batch_id,sample_id)

实现预处理函数

标准化

def  normalize(x):
    """
    :param x:图片数据,图片的shape=(32,32,3)
    :return: 返回归一化像素后的图片(像素取值范围:[0,1])(数组)
    归一化处理图片数据,将其缩放到[0,1],shape不变,仍未(32,32,3)
    """
    result = 0 + (x -x.min())*1.0/(x.max()-x.min())
    return result

标签进行one-hot编码

def one_hot_encode(x):
    """
    :param x:样本标签列表
    :return: 返回one-hot编码后的样本标签列表,是一个numpy数组
    """
    encode = []
    for value in x:
        list = np.zeros([10])
        list[value] = 1
        encode.append(list)
    return np.array(encode)

预处理训练数据集,验证数据集,测试数据集

#45000张训练图片,5000张验证图片调超参的
#10000张测试图片
helper.preprocess_and_save_data(
    cifar10_dataset_folder_path,normalize,one_hot_encode)

#第一个checkpoint,将预处理的数据保存到本地
#读取已经保存的验证集
file = open("./preprocess_sets/preprocess_validation.p",mode="rb")
valid_features,valid_labels = pickle.load(file)
# shape = (5000,32,32,3)
#shape = (5000,10)

构建神经网络训练数据

#注:对placeholder命名可以用于加载保存的placeholder数据
#Tensorflow的None表示的是形状可以是动态大小

图片输入

def neural_net_image_input(image_shape):
    """
    :param images_shape: 图片的形状4D:(batch_size,height,width,depth)
    :return: Tensor of image input 输入图片的张量
    """
    layer_0 = tf.placeholder(
        tf.float32,
        shape= [None,image_shape[0],image_shape[1],image_shape[2]],
        name="x")
    return layer_0

标签输入

def neural_net_label_input(n_classes):
    """
    :param n_classes:样本标签类别个数
    :return: 返回一个样本标签的Tensor
    """
    label = tf.placeholder(tf.float32,
                           shape=[None,n_classes],name="y")
    return label

dropout 留存率

def neural_net_keep_prob_input():
    """
    :return:返回一个keep_prob的Tensor ,也就是keep_prob的
     placeholder
    """
    keep_prob = tf.placeholder(tf.float32,name="keep_prob")
    return keep_prob

卷积和最大池化联合层

def conv2d_maxpool(
        x_tensor,conv_kernels_num,conv_ksize,conv_strides,
        pool_ksize,pool_strides,padding="SAME",std=0.1,activation=tf.nn.relu):
    """
    先实现卷积再实现最大池化
    :param x_tensor: Tensor输入
    :param conv_kernels_num:卷积核个数,卷积输出个数/通道数
    :param conv_ksize:卷积核二维窗口大小
    :param conv_strides:卷积步长
    :param pool_ksize:最大池化二维(每一通道)窗口大小
    :param pool_strides:最大池化步长
    :param std:标准差
    :return:返回卷积最大池化后的x_tensor
    """
    #过滤器由多个卷积核组成,每层卷积核有多个,而过滤器只有一个
    filter_weights = tf.Variable(
        tf.truncated_normal(shape= [conv_ksize[0],
                                    conv_ksize[1],
                                    x_tensor.get_shape().as_list()[3],
                                    conv_kernels_num],stddev=std))
    biases = tf.Variable(tf.zeros(conv_kernels_num))
    conv_layer = tf.nn.conv2d(x_tensor,filter_weights,
                              strides=[1,conv_strides[0],conv_strides[1],1],
                              padding=padding)
    conv_layer = tf.nn.bias_add(conv_layer,biases)
    maxpool_logits = tf.nn.max_pool(conv_layer,
                             ksize=[1,pool_ksize[0],pool_ksize[1],1],
                             strides=[1,pool_strides[0],pool_strides[1],1],
                             padding=padding)
    if activation == tf.nn.relu :
        return tf.nn.relu(maxpool_logits)
    else:
        return maxpool_logits

卷积和平均池化联合层

def conv2d_avgpool(
        x_tensor,conv_kernels_num,conv_ksize,conv_strides,
        pool_ksize,pool_strides,padding="SAME",std=1,activation=tf.nn.relu):
    """
    先实现卷积再实现最大池化
    :param x_tensor: Tensor输入
    :param conv_kernels_num:卷积核个数,卷积输出个数/通道数
    :param conv_ksize:卷积核二维窗口大小
    :param conv_strides:卷积步长
    :param pool_ksize:最大池化二维(每一通道)窗口大小
    :param pool_strides:最大池化步长
    :param std:标准差
    :return:返回卷积最大池化后的x_tensor
    """
    #过滤器由多个卷积核组成,每层卷积核有多个,而过滤器只有一个
    filter_weights = tf.Variable(
        tf.truncated_normal(shape= [conv_ksize[0],
                                    conv_ksize[1],
                                    x_tensor.get_shape().as_list()[3],
                                    conv_kernels_num],stddev=std))
    biases = tf.Variable(tf.zeros(conv_kernels_num))
    conv_layer = tf.nn.conv2d(x_tensor,filter_weights,
                              strides=[1,conv_strides[0],conv_strides[1],1],
                              padding=padding)
    conv_layer = tf.nn.bias_add(conv_layer,biases)
    avgpool_logits = tf.nn.avg_pool(conv_layer,
                             ksize=[1,pool_ksize[0],pool_ksize[1],1],
                             strides=[1,pool_strides[0],pool_strides[1],1],
                             padding=padding)
    if activation == tf.nn.relu :
        return tf.nn.relu(avgpool_logits)
    else:
        return avgpool_logits

扁平化层,也就是拉直层,实现flatten函数

#将x_tensor从4维变为2维,shape为(m,n)
#m为样本数目,n为特征数目(扁平化图片维度)
def flatten(x_tensor):
    feature_dism = (x_tensor.get_shape().as_list()[1]*
                    x_tensor.get_shape().as_list()[2]*
                    x_tensor.get_shape().as_list()[3])

   flat_x_tensor =tf.reshape( x_tensor,[-1,feature_dism])

   return flat_x_tensor

全连接层

def fully_connect(x_tensor,num_outputs,activation=tf.nn.relu):
    """
    :param x_tensor:输入Tensor
    :param num_outputs: 输出神经元个数
    :return:
    """
    full_weights = tf.Variable(tf.truncated_normal(
        shape=[x_tensor.get_shape().as_list()[1],num_outputs],stddev=0.1))
    full_biases = tf.Variable(tf.zeros(num_outputs))

   logits = tf.add(tf.matmul(x_tensor,full_weights),full_biases)
    if activation == tf.nn.relu :
        return tf.nn.relu(logits)
    else:
        return logits

输出层

def output(x_tensor,num_outputs,activation=None):
    """
    :param x_tensor:输入的2D Tensor
    :param num_outputs:分类类别数目
    :return:
    """
    out_weights = tf.Variable(tf.truncated_normal(
        shape = [x_tensor.get_shape().as_list()[1],num_outputs],stddev=0.1))
    out_biases = tf.Variable(tf.zeros([num_outputs]))

   out_logits = tf.add(tf.matmul(x_tensor,out_weights),out_biases)

   if activation == tf.nn.relu:
       return tf.nn.relu(out_logits)
    else:
        return out_logits

搭建卷积模型

def conv_net(x_tensor,keep_prob):
    #shape = (None,32,32,3)
    conv_layer_1 = conv2d_maxpool(x_tensor,32,(3,3),[1,1],
                                  pool_ksize=(2,2),
                                  pool_strides=(2,2),std=0.1)
    # conv_layer_1 = tf.nn.dropout(conv_layer_1, keep_prob=keep_prob)
    #shape = (None,16,16,32)

   conv_layer_2 = conv2d_maxpool(conv_layer_1,64,(3,3),[1,1],
	                                 pool_ksize=(2,2),
	                                 pool_strides=(2,2),std=0.1)
    # conv_layer_2 = tf.nn.dropout(conv_layer_2, keep_prob=keep_prob)
    #shape = (None,8,8,64)
    conv_layer_3 = conv2d_maxpool(conv_layer_2,64,(3,3),[1,1],
                                 pool_ksize=[2,2],
                                 pool_strides=[2,2],std=0.1)
    # conv_layer_3 = tf.nn.dropout(conv_layer_3, keep_prob=keep_prob)
   conv_layer_3  = flatten(conv_layer_3)
    #shape = (None,4096)
   full_conn_layer_1 = fully_connect(conv_layer_3,num_outputs=1024)
   full_conn_layer_1 = tf.nn.dropout(full_conn_layer_1, keep_prob=keep_prob)
   #shape = (None,1024)
   output_logits = output(full_conn_layer_1,10)
   #shape = (None,10)
   return output_logits

初始化

x = neural_net_image_input([32,32,3])
y = neural_net_label_input(10)
keep_prob = neural_net_keep_prob_input()
epochs = 20
batch_size = 256
batch_num = 5
drop_keep = 0.8


logits = conv_net(x,keep_prob=drop_keep)
logits = tf.identity(logits,name="logits")
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
    logits=logits,labels=y))
optimizer = tf.train.AdamOptimizer().minimize(loss)
correct_pred = tf.equal(tf.argmax(logits,1),tf.argmax(y,1))
accuracy = tf.reduce_mean(
    tf.cast(correct_pred,tf.float32),name="accuracy")

init_op = tf.global_variables_initializer()
save_model_path ="./models/image_classification.ckpt"

开始训练

print("开始训练..........")
with tf.Session()  as sess:
    sess.run(init_op)
    for epoch_i in range(epochs):
        for batch_id in range(batch_num):
            for batch_features,batch_labels  in  helper. load_preprocess_training_batch(batch_id+1,batch_size):
                _ = sess.run(optimizer, feed_dict={x: batch_features,y: batch_labels, keep_prob: drop_keep})
                train_loss = sess.run(loss,feed_dict={x:batch_features, y:batch_labels,keep_prob:1.})
                valid_accuracy = sess.run(accuracy,feed_dict={x:valid_features[:batch_size], y:valid_labels[:batch_size],keep_prob:1.})
                train_accuracy = sess.run(accuracy,feed_dict={x:batch_features,y:batch_labels,keep_prob:1.})
                print("Epoch:{:<4}--Training loss:{:<4}--Training accuracy:{:<4}--Validation accuracy:{:<4}".
                      format(epoch_i,train_loss,train_accuracy,valid_accuracy))

保存模型

saver = tf.train.Saver()
save_path = saver.save(sess,save_model_path)

加载模型进行测试

import tensorflow as tf
import pickle
import helper
import random
import numpy as np
batch_size = 256
n_samples =4
try:
    if batch_size:
        pass
except NameError:
    batch_size = 64

load_model_path ="./models/image_classification.ckpt"
n_samples = 4
#前三个概率预测中有就算正确
top_n_predictions = 3
test_file = open("./preprocess_sets/preprocess_test.p",mode="rb")
def test_model():
    #取测试特征样本,测试样本标签
    test_features,test_labels = pickle.load(test_file)
    loaded_graph = tf.Graph()

   with tf.Session(graph=loaded_graph) as sess:
        sess.run(tf.global_variables_initializer())
        #读取图模型meta
        load_model = tf.train.import_meta_graph(load_model_path + ".meta")
        #读取变量(权重,偏置项),它会去查看checkpoint最新的模型名字
        load_model.restore(sess,load_model_path)
        #从已经读取模型中获取Tensor
        loaded_x = loaded_graph.get_tensor_by_name("x:0")
        loaded_y = loaded_graph.get_tensor_by_name("y:0")
        loaded_keep_prob = loaded_graph.get_tensor_by_name("keep_prob:0")
        loaded_logits = loaded_graph.get_tensor_by_name("logits:0")
        loaded_accuracy = loaded_graph.get_tensor_by_name("accuracy:0")

   #获取每个batch的准确率,再求平均值,这样可以节约内存
        test_batch_acc_total = 0  #所有样本准确率之和
        test_batch_count = 0    #所有样本数
	    for batch_features,batch_labels  in  helper.batch_features_labels(test_features,test_labels,batch_size):		      
            test_batch_acc_total += sess.run(loaded_accuracy,
                                             feed_dict={loaded_x:batch_features,loaded_y:batch_labels,loaded_keep_prob:1})
            test_batch_count  += 1
        print("test accuracy:{:<3}".format(test_batch_acc_total/test_batch_count))
        # random_test_features, random_test_labels = tuple(zip(*random.sample(list(zip(test_features, test_labels)), n_samples)))
        # random_test_predictions = sess.run(
        #     tf.nn.top_k(tf.nn.softmax(loaded_logits), top_n_predictions),
        #     feed_dict={loaded_x: random_test_features, loaded_y: random_test_labels, loaded_keep_prob: 1.0})
        # helper.display_image_predictions(random_test_features, random_test_labels, random_test_predictions)
        #随机打印一个例子
        random_test_features,random_test_labels = tuple(zip(*random.sample(list(zip(test_features,test_labels)),n_samples)))
        #shape = (4,3)
        random_test_predictions = sess.run(tf.nn.top_k(tf.nn.softmax(loaded_logits),k=top_n_predictions),
                                           feed_dict={loaded_x:random_test_features,loaded_y:random_test_labels,loaded_keep_prob:1.})
        print(random_test_predictions.indices)
        print(random_test_predictions.values)
        # print(np.shape(random_test_predictions))
        helper.display_image_predictions(random_test_features,random_test_labels,random_test_predictions)

test_model()

help.py帮助模块

import pickle
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import LabelBinarizer

从文件中加载标签名

def _load_label_names():
    """
    Load the label names from file
    """
    return ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']

加载cifar10的批次样本

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id):
    """
    Load a batch of the dataset
    """
    with open(cifar10_dataset_folder_path + '/data_batch_' + str(batch_id), mode='rb') as file:
        batch = pickle.load(file, encoding='latin1')

    features = batch['data'].reshape((len(batch['data']), 3, 32, 32)).transpose(0, 2, 3, 1)
    labels = batch['labels']

    return features, labels

显示数据集的状态信息

def display_stats(cifar10_dataset_folder_path, batch_id, sample_id):
    """
    Display Stats of the the dataset
    """
    batch_ids = list(range(1, 6))

    if batch_id not in batch_ids:
        print('Batch Id out of Range. Possible Batch Ids: {}'.format(batch_ids))
        return None

    features, labels = load_cfar10_batch(cifar10_dataset_folder_path, batch_id)

    if not (0 <= sample_id < len(features)):
        print('{} samples in batch {}.  {} is out of range.'.format(len(features), batch_id, sample_id))
        return None

    print('\nStats of batch {}:'.format(batch_id))
    print('Samples: {}'.format(len(features)))
    print('Label Counts: {}'.format(dict(zip(*np.unique(labels, return_counts=True)))))
    print('First 20 Labels: {}'.format(labels[:20]))

    sample_image = features[sample_id]
    sample_label = labels[sample_id]
    label_names = _load_label_names()

    print('\nExample of Image {}:'.format(sample_id))
    print('Image - Min Value: {} Max Value: {}'.format(sample_image.min(), sample_image.max()))
    print('Image - Shape: {}'.format(sample_image.shape))
    print('Label - Label Id: {} Name: {}'.format(sample_label, label_names[sample_label]))
    plt.axis('off')
    plt.imshow(sample_image)
    plt.show()

预处理数据并保存到文件

def _preprocess_and_save(normalize, one_hot_encode, features, labels, filename):
    """
    Preprocess data and save it to file
    """
    features = normalize(features)
    labels = one_hot_encode(labels)
    # pickle模块是能够让我们直接在文件中存储几乎任何Python对象的高级工具
    #存
    pickle.dump((features, labels), open(filename, 'wb'))

预处理训练集、验证集数据

def preprocess_and_save_data(cifar10_dataset_folder_path, normalize, one_hot_encode):
    """
    Preprocess Training and Validation Data
    """
    n_batches = 5
    valid_features = []
    valid_labels = []

    for batch_i in range(1, n_batches + 1):
        features, labels = load_cfar10_batch(cifar10_dataset_folder_path, batch_i)
        validation_count = int(len(features) * 0.1)

        # Prprocess and save a batch of training data
        _preprocess_and_save(
            normalize,
            one_hot_encode,
            features[:-validation_count],
            labels[:-validation_count],
            './preprocess_sets/preprocess_batch_' + str(batch_i) + '.p')

        # Use a portion of training batch for validation
        valid_features.extend(features[-validation_count:])
        valid_labels.extend(labels[-validation_count:])

    # Preprocess and Save all validation data
    _preprocess_and_save(
        normalize,
        one_hot_encode,
        np.array(valid_features),
        np.array(valid_labels),
        './preprocess_sets/preprocess_validation.p')

    with open(cifar10_dataset_folder_path + '/test_batch', mode='rb') as file:
        batch = pickle.load(file, encoding='latin1')

    # load the test data
    test_features = batch['data'].reshape((len(batch['data']), 3, 32, 32)).transpose(0, 2, 3, 1)
    test_labels = batch['labels']

    # Preprocess and Save all test data
    _preprocess_and_save(
        normalize,
        one_hot_encode,
        np.array(test_features),
        np.array(test_labels),
        './preprocess_sets/preprocess_test.p')

分割批次样本的特征和标签

def batch_features_labels(features, labels, batch_size):
    """
    Split features and labels into batches
    """
    for start in range(0, len(features), batch_size):
        end = min(start + batch_size, len(features))
        yield features[start:end], labels[start:end]

加载预处理训练集数据

def load_preprocess_training_batch(batch_id, batch_size):
    """
    Load the Preprocessed Training data and return them in batches of <batch_size> or less
    """
    filename = './preprocess_sets/preprocess_batch_' + str(batch_id) + '.p'
    features, labels = pickle.load(open(filename, mode='rb'))

    # Return the training data in batches of size <batch_size> or less
    return batch_features_labels(features, labels, batch_size)

图片预测展示

def display_image_predictions(features, labels, predictions):
    n_classes = 10
    label_names = _load_label_names()
    label_binarizer = LabelBinarizer()
    label_binarizer.fit(range(n_classes))
    label_ids = label_binarizer.inverse_transform(np.array(labels))
    print("labels:",labels)
    print("label_id",label_ids)
    fig, axies = plt.subplots(nrows=4, ncols=2)
    fig.tight_layout()
    fig.suptitle('Softmax Predictions', fontsize=20, y=1.1)

    n_predictions = 3
    margin = 0.05
    ind = np.arange(n_predictions)
    width = (1. - 2. * margin) / n_predictions
    #indices对应的标签数组
    for image_i, (feature, label_id, pred_indicies, pred_values) in enumerate(zip(features, label_ids, predictions.indices, predictions.values)):
        pred_names = [label_names[pred_i] for pred_i in pred_indicies]
        correct_name = label_names[label_id]

        axies[image_i][0].imshow(feature)
        axies[image_i][0].set_title(correct_name)
        axies[image_i][0].set_axis_off()

        # barh()表示绘制水平方向的条形图，基本使用方法为：barh(y, width, height=0.8, align='center')
        axies[image_i][1].barh(ind + margin, pred_values[::-1], width)
        axies[image_i][1].set_yticks(ind + margin)
        axies[image_i][1].set_yticklabels(pred_names[::-1])
        axies[image_i][1].set_xticks([0, 0.5, 1.0])
    plt.show()

检测模块problem_unittests.py

import os
import numpy as np
import tensorflow as tf
import random
from unittest.mock import MagicMock


def _print_success_message():
    print('Tests Passed')

检测文件路径

def test_folder_path(cifar10_dataset_folder_path):
    assert cifar10_dataset_folder_path is not None,\
        'Cifar-10 data folder not set.'
    assert cifar10_dataset_folder_path[-1] != '/',\
        'The "/" shouldn\'t be added to the end of the path.'
    assert os.path.exists(cifar10_dataset_folder_path),\
        'Path not found.'
    assert os.path.isdir(cifar10_dataset_folder_path),\
        '{} is not a folder.'.format(os.path.basename(cifar10_dataset_folder_path))

    train_files = [cifar10_dataset_folder_path + '/data_batch_' + str(batch_id) for batch_id in range(1, 6)]
    other_files = [cifar10_dataset_folder_path + '/batches.meta', cifar10_dataset_folder_path + '/test_batch']
    missing_files = [path for path in train_files + other_files if not os.path.exists(path)]

    assert not missing_files,\
        'Missing files in directory: {}'.format(missing_files)

    print('All files found!')

测试是否归一化

def test_normalize(normalize):
    test_shape = (np.random.choice(range(1000)), 32, 32, 3)
    test_numbers = np.random.choice(range(256), test_shape)
    normalize_out = normalize(test_numbers)

    assert type(normalize_out).__module__ == np.__name__,\
        'Not Numpy Object'

    assert normalize_out.shape == test_shape,\
        'Incorrect Shape. {} shape found'.format(normalize_out.shape)

    assert normalize_out.max() <= 1 and normalize_out.min() >= 0,\
        'Incorect Range. {} to {} found'.format(normalize_out.min(), normalize_out.max())

    _print_success_message()

测试是否哑编码

def test_one_hot_encode(one_hot_encode):
    test_shape = np.random.choice(range(1000))
    test_numbers = np.random.choice(range(10), test_shape)
    one_hot_out = one_hot_encode(test_numbers)

    assert type(one_hot_out).__module__ == np.__name__,\
        'Not Numpy Object'

    assert one_hot_out.shape == (test_shape, 10),\
        'Incorrect Shape. {} shape found'.format(one_hot_out.shape)

    n_encode_tests = 5
    test_pairs = list(zip(test_numbers, one_hot_out))
    test_indices = np.random.choice(len(test_numbers), n_encode_tests)
    labels = [test_pairs[test_i][0] for test_i in test_indices]
    enc_labels = np.array([test_pairs[test_i][1] for test_i in test_indices])
    new_enc_labels = one_hot_encode(labels)

    assert np.array_equal(enc_labels, new_enc_labels),\
        'Encodings returned different results for the same numbers.\n' \
        'For the first call it returned:\n' \
        '{}\n' \
        'For the second call it returned\n' \
        '{}\n' \
        'Make sure you save the map of labels to encodings outside of the function.'.format(enc_labels, new_enc_labels)

    _print_success_message()

检测图片样本输入

def test_nn_image_inputs(neural_net_image_input):
    image_shape = (32, 32, 3)
    nn_inputs_out_x = neural_net_image_input(image_shape)

    assert nn_inputs_out_x.get_shape().as_list() == [None, image_shape[0], image_shape[1], image_shape[2]],\
        'Incorrect Image Shape.  Found {} shape'.format(nn_inputs_out_x.get_shape().as_list())

    assert nn_inputs_out_x.op.type == 'Placeholder',\
        'Incorrect Image Type.  Found {} type'.format(nn_inputs_out_x.op.type)

    assert nn_inputs_out_x.name == 'x:0', \
        'Incorrect Name.  Found {}'.format(nn_inputs_out_x.name)

    print('Image Input Tests Passed.')

检测样本标签输入

def test_nn_label_inputs(neural_net_label_input):
    n_classes = 10
    nn_inputs_out_y = neural_net_label_input(n_classes)

    assert nn_inputs_out_y.get_shape().as_list() == [None, n_classes],\
        'Incorrect Label Shape.  Found {} shape'.format(nn_inputs_out_y.get_shape().as_list())

    assert nn_inputs_out_y.op.type == 'Placeholder',\
        'Incorrect Label Type.  Found {} type'.format(nn_inputs_out_y.op.type)

    assert nn_inputs_out_y.name == 'y:0', \
        'Incorrect Name.  Found {}'.format(nn_inputs_out_y.name)

    print('Label Input Tests Passed.')

检测dropout留存率输入

def test_nn_keep_prob_inputs(neural_net_keep_prob_input):
    nn_inputs_out_k = neural_net_keep_prob_input()

    assert nn_inputs_out_k.get_shape().ndims is None,\
        'Too many dimensions found for keep prob.  Found {} dimensions.  It should be a scalar (0-Dimension Tensor).'.format(nn_inputs_out_k.get_shape().ndims)

    assert nn_inputs_out_k.op.type == 'Placeholder',\
        'Incorrect keep prob Type.  Found {} type'.format(nn_inputs_out_k.op.type)

    assert nn_inputs_out_k.name == 'keep_prob:0', \
        'Incorrect Name.  Found {}'.format(nn_inputs_out_k.name)

    print('Keep Prob Tests Passed.')

检测卷积最大池化层

def test_con_pool(conv2d_maxpool):
    test_x = tf.placeholder(tf.float32, [None, 32, 32, 5])
    test_num_outputs = 10
    test_con_k = (2, 2)
    test_con_s = (4, 4)
    test_pool_k = (2, 2)
    test_pool_s = (2, 2)

    conv2d_maxpool_out = conv2d_maxpool(test_x, test_num_outputs, test_con_k, test_con_s, test_pool_k, test_pool_s)

    assert conv2d_maxpool_out.get_shape().as_list() == [None, 4, 4, 10],\
        'Incorrect Shape.  Found {} shape'.format(conv2d_maxpool_out.get_shape().as_list())

    _print_success_message()

检测flatten层

def test_flatten(flatten):
    test_x = tf.placeholder(tf.float32, [None, 10, 30, 6])
    flat_out = flatten(test_x)

    assert flat_out.get_shape().as_list() == [None, 10*30*6],\
        'Incorrect Shape.  Found {} shape'.format(flat_out.get_shape().as_list())

    _print_success_message()

检测全连接层

def test_fully_conn(fully_conn):
    test_x = tf.placeholder(tf.float32, [None, 128])
    test_num_outputs = 40

    fc_out = fully_conn(test_x, test_num_outputs)

    assert fc_out.get_shape().as_list() == [None, 40],\
        'Incorrect Shape.  Found {} shape'.format(fc_out.get_shape().as_list())

    _print_success_message()

检测输出层

def test_output(output):
    test_x = tf.placeholder(tf.float32, [None, 128])
    test_num_outputs = 40

    output_out = output(test_x, test_num_outputs)

    assert output_out.get_shape().as_list() == [None, 40],\
        'Incorrect Shape.  Found {} shape'.format(output_out.get_shape().as_list())

    _print_success_message()

检测卷积模型

def test_conv_net(conv_net):
    test_x = tf.placeholder(tf.float32, [None, 32, 32, 3])
    test_k = tf.placeholder(tf.float32)

    logits_out = conv_net(test_x, test_k)

    assert logits_out.get_shape().as_list() == [None, 10],\
        'Incorrect Model Output.  Found {}'.format(logits_out.get_shape().as_list())

    print('Neural Network Built!')

检测训练神经网络

def test_train_nn(train_neural_network):
    mock_session = tf.Session()
    test_x = np.random.rand(128, 32, 32, 3)
    test_y = np.random.rand(128, 10)
    test_k = np.random.rand(1)
    test_optimizer = tf.train.AdamOptimizer()

    mock_session.run = MagicMock()
    train_neural_network(mock_session, test_optimizer, test_k, test_x, test_y)

    assert mock_session.run.called, 'Session not used'

    _print_success_message()