MAXOUT神经网络及实例应用

一、maxout 神经网络的介绍

Maxout 神经网络 可以理解为单个神经元的拓展，主要是拓展单个神经元里面的**函数。将**函数变成一个网络选择器，原理就是将多个神经元并排的放在一起，从他们的输出结果中找到最大的那个，代表对特征相应最敏感，然后取这个神经元的结果参与后面的运算。

图1 单个神经元

图 2 maxout神经网络

他的公式可以表示为：
$z_{1}=w_{1}+b_{1}\\z_{2}=w_{2}+b_{2}\\z_{3}=w_{3}+b_{3}\\z_{4}=w_{4}+b_{4}\\z_{5}=w_{5}+b_{5}\\out=max(z_{1},z_{2},z_{3},z_{4},z_{5})$z1​=w1​+b1​z2​=w2​+b2​z3​=w3​+b3​z4​=w4​+b4​z5​=w5​+b5​out=max(z1​,z2​,z3​,z4​,z5​)
为什么要这么做呢？类似于人类的神经细胞，不同的神经元会因为输入的不同二产生不同的输出，即不同的细胞关系的信号不同。依赖于这个原理，现在的做法就是相当于同时使用多个神经元放在一起，哪个有效果，就用哪一个。所以这样的网络就会有更好的拟合效果。

二、实例：利用maxout神经网络实现mnist分类

完整代码：

# -*- coding: utf-8 -*-
"""
Created on Wed May 31 20:09:17 2017

@author: 代码医生
@blog：http://blog.csdn.net/lijin6249
"""
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/")

print ('输入数据:',mnist.train.images)
print ('输入数据打shape:',mnist.train.images.shape)

import pylab 
im = mnist.train.images[1]
im = im.reshape(-1,28)
pylab.imshow(im)
pylab.show()


print ('输入数据打shape:',mnist.test.images.shape)
print ('输入数据打shape:',mnist.validation.images.shape)


import tensorflow as tf #导入tensorflow库

def max_out(inputs, num_units, axis=None):
    shape = inputs.get_shape().as_list()
    if shape[0] is None:
        shape[0] = -1
    if axis is None:  # Assume that channel is the last dimension
        axis = -1
    num_channels = shape[axis]
    if num_channels % num_units:
        raise ValueError('number of features({}) is not '
                         'a multiple of num_units({})'.format(num_channels, num_units))
    shape[axis] = num_units
    shape += [num_channels // num_units]
    outputs = tf.reduce_max(tf.reshape(inputs, shape), -1, keep_dims=False)
    return outputs


tf.reset_default_graph()
# tf Graph Input
x = tf.placeholder(tf.float32, [None, 784]) # mnist data维度 28*28=784
y = tf.placeholder(tf.int32, [None]) # 0-9 数字=> 10 classes

# Set model weights
W = tf.Variable(tf.random_normal([784, 100]))
b = tf.Variable(tf.zeros([100]))


z= tf.matmul(x, W) + b
#maxout = tf.reduce_max(z,axis= 1,keep_dims=True)

maxout= max_out(z, 50)

# Set model weights
W2 = tf.Variable(tf.truncated_normal([50, 10], stddev=0.1))
b2 = tf.Variable(tf.zeros([10]))
# 构建模型
#pred = tf.nn.softmax(tf.matmul(maxout, W2) + b2)
pred = tf.matmul(maxout, W2) + b2
# 构建模型
#pred = tf.nn.softmax(z) # Softmax分类

# Minimize error using cross entropy
#cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(pred), reduction_indices=1))
cost = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=pred))

#参数设置
learning_rate = 0.04
# 使用梯度下降优化器
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)


training_epochs = 200
batch_size = 100
display_step = 1


# 启动session
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())# Initializing OP

    # 启动循环开始训练
    for epoch in range(training_epochs):
        avg_cost = 0.
        total_batch = int(mnist.train.num_examples/batch_size)
        # 遍历全部数据集
        for i in range(total_batch):
            batch_xs, batch_ys = mnist.train.next_batch(batch_size)
            # Run optimization op (backprop) and cost op (to get loss value)
            _, c = sess.run([optimizer, cost], feed_dict={x: batch_xs,
                                                          y: batch_ys})
            # Compute average loss
            avg_cost += c / total_batch
        # 显示训练中的详细信息
        if (epoch+1) % display_step == 0:
            print ("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))

    print( " Finished!")

运行结果及说明：

第一个shape是一个55000行，784列的矩阵，即，训练集有55000张图片。第一个维度是用来索引图片的，第二个维度是用来索引图片的像素点。同理，测试集和验证集各有10000张图片和5000张图片。

在网络模型部分，添加一层maxout，然后将maxout作为softmax的交叉商输入，设置学习率为0.04，迭代次数为200，得到如下结果：

有10000张图片和5000张图片。

在网络模型部分，添加一层maxout，然后将maxout作为softmax的交叉商输入，设置学习率为0.04，迭代次数为200，得到如下结果：

[外链图片转存中…(img-3eGhU6tV-1578196791581)]

总结 ：maxout的拟合效果很强大，但是也会有节点过多，参数过多，训练过慢的缺点。