使用tensorflow layers相关API快速构建卷积神经网络

conv2d(
    inputs,
    filters,
    kernel_size,
    strides=(1, 1),
    padding='valid',
    data_format='channels_last',
    dilation_rate=(1, 1),
    activation=None,
    use_bias=True,
    kernel_initializer=None,
    bias_initializer=init_ops.zeros_initializer(),
    kernel_regularizer=None,
    bias_regularizer=None,
    activity_regularizer=None,
    kernel_constraint=None,
    bias_constraint=None,
    trainable=True,
    name=None,
    reuse=None
)

# 参数解释如下：

input表示输入tensor
filters表示输出的深度维度、也是卷积核的个数
kernel_size 卷积核的大小，一个整数或者是一个元组
strides=(1, 1), 卷积时候的步长、一个整数或者一个元组,默认是1x1的步长
padding 填充方式，默认valid意思是不够的丢弃，如果是same表示不够时候补零
dilation_rate 是否使用膨胀卷积，默认不使用
activation激活函数
use_bias 是否使用增益偏置
kernel_initializer卷积核初始化参数方式，如果设置为None默认为xavier_initializer
bias_initializer 增益初始化，默认初始化为零
kernel_regularizer卷积核正则化
bias_regularizer 增益偏置正则化
activity_regularizer对输出进行正则化
kernel_constraint 约束、当核被Optimizer更新后应用到核上。Optimizer用来实现对权重矩阵的范数约束或者值约束。映射函数必须将未被影射的变量作为输入，且一定输出映射后的变量（有相同的大小）。做异步的分布式训练时，使用约束可能是不安全的。
bias_constraint 约束、当偏差向量被Optimizer更新后应用到偏差向量上
trainable 是否可训练，废话，当然是True
name 给这个卷积操作取个名字，方便以后获取它

max_pooling2d(
    inputs,
    pool_size, 
    strides,
    padding='valid', 
    data_format='channels_last',
    name=None
)
input表示输入tensor
pool_size表示输出的深度维度、也是卷积核的个数
strides=(1, 1), 卷积时候的步长、一个整数或者一个元组,默认是1x1的步长
padding 填充方式，默认valid意思是不够的丢弃，如果是same表示不够时候补零
data_format表示数据格式顺序，默认是channels_last数据的格式顺序为(batch, height, width, channels)。如果是 channels_first数据格式顺序为 (batch, channels, height, width)
name最大池化层的名字

x = tf.placeholder(shape=[None, 784], dtype=tf.float32)
y = tf.placeholder(shape=[None, 10], dtype=tf.float32)
keep_prob = tf.placeholder(dtype=tf.float32)
x_image = tf.reshape(x, [-1, 28, 28, 1])

def conv_net(x_dict, n_classes, dropout):
    conv1 = tf.layers.conv2d(x_dict, 32, 5, activation=tf.nn.relu)
    pool1 = tf.layers.max_pooling2d(conv1, pool_size=2, strides=2)

    conv2 = tf.layers.conv2d(pool1, 64, 3, activation=tf.nn.relu)
    pool2 = tf.layers.max_pooling2d(conv2, pool_size=2, strides=2)

    fc1 = tf.layers.flatten(pool2, name="fc1")
    fc2 = tf.layers.dense(fc1, 1024)
    fc2 = tf.layers.dropout(fc2, rate=dropout)
    out = tf.layers.dense(fc2, n_classes)
    return out

logits = conv_net(x_image, num_classes, keep_prob)
cross_loss = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y)
loss = tf.reduce_mean(cross_loss)
step = tf.train.AdamOptimizer(learning_rate).minimize(loss)

# accuracy
acc_mat = tf.equal(tf.argmax(logits, 1), tf.argmax(y, 1))
acc = tf.reduce_sum(tf.cast(acc_mat, tf.float32))
prediction = tf.argmax(logits, axis=1)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    for i in range(20000):
        is_training = True
        batch_xs, batch_ys = mnist.train.next_batch(min_batch)
        _, curr_loss = sess.run([step, loss], feed_dict={x: batch_xs, y: batch_ys, keep_prob: 0.5})
        if (i + 1) % 1000 == 0:
            is_training = False
            conv_y, curr_acc = sess.run([logits, acc], feed_dict={x: mnist.test.images, y: mnist.test.labels, keep_prob: 1.0})
            print("current loss: %f, current test Accuracy : %f" % (curr_loss, curr_acc))