• Maxout网络实现MNIST分类： # 使用 Maxout 网络实现 MNIST 分类 from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets("MNIST_data/", one_hot = True) import ...
退化学习率实例：
import tensorflow as tf

global_step = tf.Variable(0, trainable = False)
initial_learning_rate = 0.1  # 初始化学习率
# 退化学习率，tf.train.exponential_decay : 当前迭代到 global_step后， 学习率每一步都按照每10步去缩小到 0.9的速度衰减
learning_rate = tf.train.exponential_decay( initial_learning_rate,
global_step = global_step,
decay_steps = 10, decay_rate = 0.9)
# 优化函数
# global_step 叠加

with tf.Session() as sess:
tf.global_variables_initializer().run()
print(sess.run(learning_rate))

for i in range(30):
print(g, rate)
结果： # 0.1 # 1 0.1 # 2 0.09895193 # 3 0.09791484 # 4 0.09688862 # 5 0.095873155 # 6 0.094868325 # 7 0.09387404 # 8 0.092890166 # 9 0.09191661 # 10 0.09095325 # 11 0.089999996 # 12 0.08905673 # 13 0.087199755 # 14 0.08628584 # 15 0.08628584 # 16 0.0853815

Maxout网络实现MNIST分类：


# 使用 Maxout 网络实现 MNIST 分类
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot = True)
import pylab

tf.reset_default_graph()
# 定义占位符
x = tf.placeholder(tf.float32, [None, 784])  # MNIST 数据集的维度是 28*28 = 784
y = tf.placeholder(tf.float32, [None, 10])

w = tf.Variable(tf.random_normal([784, 10]))
b = tf.Variable(tf.zeros([10]))

z = tf.matmul(x , w) +b
maxout = tf.reduce_max(z ,axis =1, keep_dims = True)
# 设置学习参数
w2 = tf.Variable(tf.truncated_normal([1,10], stddev=0.1))
b2 = tf.Variable(tf.zeros([1]))
# 构建模型 # 损失函数
cost = tf.nn.softmax(tf.matmul(maxout, w2) +b2)
learning_rate = 0.04
# 梯度下降优化器
trianing_epochs = 25
batch_size = 100
display_step = 1

# 启动 session
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())  # 初始化 OP
# 启动循环开始训练
for epoch in range(trianing_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)
# 运行优化器
_, c = sess.run([optimizer, cost], feed_dict = {x: batch_xs, y:batch_ys})
# 计算平均 loss 值
avg_cost += c / total_batch
# 显示训练中的详细信息
if (epoch+1) % display_step == 0:
print('epoch = ' , '%s' %(epoch+1))
print( 'cost= ' , '%s' %avg_cost)
print("Finished !")



展开全文
• 版权声明：本文为博主原创文章，欢迎转载，转载请注明原文地址、作者信息。 ... Maxout网络学习原文地址：http://blog.csdn.net/hjimce/...


版权声明：本文为博主原创文章，欢迎转载，转载请注明原文地址、作者信息。 https://blog.csdn.net/hjimce/article/details/50414467

Maxout网络学习
原文地址：http://blog.csdn.net/hjimce/article/details/50414467
作者：hjimce
一、相关理论
本篇博文主要讲解2013年，ICML上的一篇文献：《Maxout  Networks》，这个算法我目前也很少用到，个人感觉最主要的原因应该是这个算法参数个数会成k倍增加(k是maxout的一个参数)，不过没关系，对于我们来说知识积累才是最重要的，指不定某一天我们就需要用到这个算法，技多不压身。个人感觉Maxout网络和Dropout有很多相似的地方。
本篇博文将从什么是maxout网络讲起，先解答maxout的源码层实现，因为很多人最感兴趣的还是算法要怎么实现，当然我也是这样的。我看文献，一般最在意的还是源码的实现，有的文献理论公式推导了十几页，结果5行代码搞定，我看到想哭，这也许就是我讨厌做学术研究的原因吧。知道了源码怎么实现后，我们简单啰嗦一下maxout相关的理论意义。

二、Maxout算法流程
1、算法概述
开始前我们先讲解什么叫maxout networks，等我们明白了什么叫maxout 网络后，再对maxout的相理论意义做出解释。Maxout是深度学习网络中的一层网络，就像池化层、卷积层一样等，我们可以把maxout 看成是网络的激活函数层，这个后面再讲解，本部分我们要先知道什么是maxout。我们假设网络某一层的输入特征向量为：X=（x1,x2,……xd），也就是我们输入是d个神经元。Maxout隐藏层每个神经元的计算公式如下：

上面的公式就是maxout隐藏层神经元i的计算公式。其中，k就是maxout层所需要的参数了，由我们人为设定大小。就像dropout一样，也有自己的参数p(每个神经元dropout概率)，maxout的参数是k。公式中Z的计算公式为：

权重w是一个大小为(d,m,k)三维矩阵，b是一个大小为(m,k)的二维矩阵，这两个就是我们需要学习的参数。如果我们设定参数k=1，那么这个时候，网络就类似于以前我们所学普通的MLP网络。
我们可以这么理解，本来传统的MLP算法在第i层到第i+1层，参数只有一组，然而现在我们不怎么干了，我们在这一层同时训练n组参数，然后选择激活值最大的作为下一层神经元的激活值。下面还是用一个例子进行讲解，比较容易搞懂。
为了简单起见，假设我们网络第i层有2个神经元x1、x2，第i+1层的神经元个数为1个，如下图所示：

(1)以前MLP的方法。我们要计算第i+1层，那个神经元的激活值的时候，传统的MLP计算公式就是：
z=W*X+b
out=f(z)
其中f就是我们所谓的激活函数，比如Sigmod、Relu、Tanh等。
(2)Maxout 的方法。如果我们设置maxout的参数k=5，maxout层就如下所示：

相当于在每个输出神经元前面又多了一层。这一层有5个神经元，此时maxout网络的输出计算公式为：
z1=w1*x+b1
z2=w2*x+b2
z3=w3*x+b3
z4=w4*x+b4
z5=w5*x+b5
out=max(z1,z2,z3,z4,z5)
所以这就是为什么采用maxout的时候，参数个数成k倍增加的原因。本来我们只需要一组参数就够了，采用maxout后，就需要有k组参数。
三、源码实现
ok，为了学习maxout源码的实现过程，我这边引用keras的源码maxout的实现，进行讲解。keras的网站为：http://keras.io/   。项目源码网站为：https://github.com/fchollet/keras。下面是keras关于maxout网络层的实现函数：

#maxout 网络层类的定义
class MaxoutDense(Layer):
# 网络输入数据矩阵大小为(nb_samples, input_dim)
# 网络输出数据矩阵大小为(nb_samples, output_dim)
input_ndim = 2
#nb_feature就是我们前面说的k的个数了，这个是maxout层特有的参数
def __init__(self, output_dim, nb_feature=4,
init='glorot_uniform', weights=None,
W_regularizer=None, b_regularizer=None, activity_regularizer=None,
W_constraint=None, b_constraint=None, input_dim=None, **kwargs):
self.output_dim = output_dim
self.nb_feature = nb_feature
self.init = initializations.get(init)

self.W_regularizer = regularizers.get(W_regularizer)
self.b_regularizer = regularizers.get(b_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)

self.W_constraint = constraints.get(W_constraint)
self.b_constraint = constraints.get(b_constraint)
self.constraints = [self.W_constraint, self.b_constraint]

self.initial_weights = weights
self.input_dim = input_dim
if self.input_dim:
kwargs['input_shape'] = (self.input_dim,)
self.input = K.placeholder(ndim=2)
super(MaxoutDense, self).__init__(**kwargs)
#参数初始化部分
def build(self):
input_dim = self.input_shape[1]

self.W = self.init((self.nb_feature, input_dim, self.output_dim))#nb_feature是我们上面说的k。
self.b = K.zeros((self.nb_feature, self.output_dim))

self.params = [self.W, self.b]
self.regularizers = []

if self.W_regularizer:
self.W_regularizer.set_param(self.W)
self.regularizers.append(self.W_regularizer)

if self.b_regularizer:
self.b_regularizer.set_param(self.b)
self.regularizers.append(self.b_regularizer)

if self.activity_regularizer:
self.activity_regularizer.set_layer(self)
self.regularizers.append(self.activity_regularizer)

if self.initial_weights is not None:
self.set_weights(self.initial_weights)
del self.initial_weights

def get_output(self, train=False):
X = self.get_input(train)#需要切记这个x的大小是(nsamples,input_num)
# -- don't need activation since it's just linear.
output = K.max(K.dot(X, self.W) + self.b, axis=1)#maxout激活函数
return output


看上面的代码的话，其实只需要看get_output()函数，就知道maxout的实现了。所以说有的时候，一篇文献的代码，其实就只有几行代码，maxout就仅仅只有一行代码而已：

output = K.max(K.dot(X, self.W) + self.b, axis=1)#maxout激活函数

下面在简单啰嗦一下相关的理论，毕竟文献的作者写了那么多页，我们总得看一看才行。Maxout可以看成是一个激活函数 ，然而它与原来我们以前所学的激活函数又有所不同。传统的激活函数：

比如阈值函数、S函数等。maxout激活函数，它具有如下性质：
1、maxout激活函数并不是一个固定的函数，不像Sigmod、Relu、Tanh等函数，是一个固定的函数方程
2、它是一个可学习的激活函数，因为我们W参数是学习变化的。
3、它是一个分段线性函数：

然而任何一个凸函数，都可以由线性分段函数进行逼近近似。其实我们可以把以前所学到的激活函数：relu、abs激活函数，看成是分成两段的线性函数，如下示意图所示：

maxout是一个函数逼近器，对于一个标准的MLP网络来说，如果隐藏层的神经元足够多，那么理论上我们是可以逼近任意的函数的。类似的，对于maxout 网络也是一个函数逼近器。
定理1：对于任意的一个连续分段线性函数g(v)，我们可以找到两个凸的分段线性函数h1(v)、h2(v)，使得这两个凸函数的差值为g(v)：

参考文献：
1、《Maxout  Networks》

展开全文
• Maxout网络的剪枝，李映虹，高博扬，近年来，Maxout网络在计算机视觉和语音识别等领域均取得了很好的成果。与Dropout方法类似，Maxout网络通过对神经网络每层单元进行分组��
• ## 深度学习（二十三）Maxout网络学习

万次阅读 多人点赞 2015-12-27 22:45:16
Maxout网络学习 Maxout是深度学习网络中的一层网络，就像什么激活函数层、池化层、卷积层一样。我们假设网络某一层的输入特征向量为：X=（x1,x2,……xd），也就是我们输入是d个神经元。Maxout隐藏层每个神经元的...
Maxout网络学习
原文地址：http://blog.csdn.net/hjimce/article/details/50414467
作者：hjimce
一、相关理论
本篇博文主要讲解2013年，ICML上的一篇文献：《Maxout  Networks》，这个算法我目前也很少用到，个人感觉最主要的原因应该是这个算法参数个数会成k倍增加(k是maxout的一个参数)，不过没关系，对于我们来说知识积累才是最重要的，指不定某一天我们就需要用到这个算法，技多不压身。个人感觉Maxout网络和Dropout有很多相似的地方。
本篇博文将从什么是maxout网络讲起，先解答maxout的源码层实现，因为很多人最感兴趣的还是算法要怎么实现，当然我也是这样的。我看文献，一般最在意的还是源码的实现，有的文献理论公式推导了十几页，结果5行代码搞定，我看到想哭，这也许就是我讨厌做学术研究的原因吧。知道了源码怎么实现后，我们简单啰嗦一下maxout相关的理论意义。

二、Maxout算法流程
1、算法概述
开始前我们先讲解什么叫maxout networks，等我们明白了什么叫maxout 网络后，再对maxout的相理论意义做出解释。Maxout是深度学习网络中的一层网络，就像池化层、卷积层一样等，我们可以把maxout 看成是网络的激活函数层，这个后面再讲解，本部分我们要先知道什么是maxout。我们假设网络某一层的输入特征向量为：X=（x1,x2,……xd），也就是我们输入是d个神经元。Maxout隐藏层每个神经元的计算公式如下：

上面的公式就是maxout隐藏层神经元i的计算公式。其中，k就是maxout层所需要的参数了，由我们人为设定大小。就像dropout一样，也有自己的参数p(每个神经元dropout概率)，maxout的参数是k。公式中Z的计算公式为：

权重w是一个大小为(d,m,k)三维矩阵，b是一个大小为(m,k)的二维矩阵，这两个就是我们需要学习的参数。如果我们设定参数k=1，那么这个时候，网络就类似于以前我们所学普通的MLP网络。
我们可以这么理解，本来传统的MLP算法在第i层到第i+1层，参数只有一组，然而现在我们不怎么干了，我们在这一层同时训练n组参数，然后选择激活值最大的作为下一层神经元的激活值。下面还是用一个例子进行讲解，比较容易搞懂。
为了简单起见，假设我们网络第i层有2个神经元x1、x2，第i+1层的神经元个数为1个，如下图所示：

(1)以前MLP的方法。我们要计算第i+1层，那个神经元的激活值的时候，传统的MLP计算公式就是：
z=W*X+b
out=f(z)
其中f就是我们所谓的激活函数，比如Sigmod、Relu、Tanh等。
(2)Maxout 的方法。如果我们设置maxout的参数k=5，maxout层就如下所示：

相当于在每个输出神经元前面又多了一层。这一层有5个神经元，此时maxout网络的输出计算公式为：
z1=w1*x+b1
z2=w2*x+b2
z3=w3*x+b3
z4=w4*x+b4
z5=w5*x+b5
out=max(z1,z2,z3,z4,z5)
所以这就是为什么采用maxout的时候，参数个数成k倍增加的原因。本来我们只需要一组参数就够了，采用maxout后，就需要有k组参数。
三、源码实现
ok，为了学习maxout源码的实现过程，我这边引用keras的源码maxout的实现，进行讲解。keras的网站为：http://keras.io/   。项目源码网站为：https://github.com/fchollet/keras。下面是keras关于maxout网络层的实现函数：

#maxout 网络层类的定义
class MaxoutDense(Layer):
# 网络输入数据矩阵大小为(nb_samples, input_dim)
# 网络输出数据矩阵大小为(nb_samples, output_dim)
input_ndim = 2
#nb_feature就是我们前面说的k的个数了，这个是maxout层特有的参数
def __init__(self, output_dim, nb_feature=4,
init='glorot_uniform', weights=None,
W_regularizer=None, b_regularizer=None, activity_regularizer=None,
W_constraint=None, b_constraint=None, input_dim=None, **kwargs):
self.output_dim = output_dim
self.nb_feature = nb_feature
self.init = initializations.get(init)

self.W_regularizer = regularizers.get(W_regularizer)
self.b_regularizer = regularizers.get(b_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)

self.W_constraint = constraints.get(W_constraint)
self.b_constraint = constraints.get(b_constraint)
self.constraints = [self.W_constraint, self.b_constraint]

self.initial_weights = weights
self.input_dim = input_dim
if self.input_dim:
kwargs['input_shape'] = (self.input_dim,)
self.input = K.placeholder(ndim=2)
super(MaxoutDense, self).__init__(**kwargs)
#参数初始化部分
def build(self):
input_dim = self.input_shape[1]

self.W = self.init((self.nb_feature, input_dim, self.output_dim))#nb_feature是我们上面说的k。
self.b = K.zeros((self.nb_feature, self.output_dim))

self.params = [self.W, self.b]
self.regularizers = []

if self.W_regularizer:
self.W_regularizer.set_param(self.W)
self.regularizers.append(self.W_regularizer)

if self.b_regularizer:
self.b_regularizer.set_param(self.b)
self.regularizers.append(self.b_regularizer)

if self.activity_regularizer:
self.activity_regularizer.set_layer(self)
self.regularizers.append(self.activity_regularizer)

if self.initial_weights is not None:
self.set_weights(self.initial_weights)
del self.initial_weights

def get_output(self, train=False):
X = self.get_input(train)#需要切记这个x的大小是(nsamples,input_num)
# -- don't need activation since it's just linear.
output = K.max(K.dot(X, self.W) + self.b, axis=1)#maxout激活函数
return output
看上面的代码的话，其实只需要看get_output()函数，就知道maxout的实现了。所以说有的时候，一篇文献的代码，其实就只有几行代码，maxout就仅仅只有一行代码而已：

output = K.max(K.dot(X, self.W) + self.b, axis=1)#maxout激活函数

下面在简单啰嗦一下相关的理论，毕竟文献的作者写了那么多页，我们总得看一看才行。Maxout可以看成是一个激活函数 ，然而它与原来我们以前所学的激活函数又有所不同。传统的激活函数：

比如阈值函数、S函数等。maxout激活函数，它具有如下性质：
1、maxout激活函数并不是一个固定的函数，不像Sigmod、Relu、Tanh等函数，是一个固定的函数方程
2、它是一个可学习的激活函数，因为我们W参数是学习变化的。
3、它是一个分段线性函数：

然而任何一个凸函数，都可以由线性分段函数进行逼近近似。其实我们可以把以前所学到的激活函数：relu、abs激活函数，看成是分成两段的线性函数，如下示意图所示：

maxout是一个函数逼近器，对于一个标准的MLP网络来说，如果隐藏层的神经元足够多，那么理论上我们是可以逼近任意的函数的。类似的，对于maxout 网络也是一个函数逼近器。
定理1：对于任意的一个连续分段线性函数g(v)，我们可以找到两个凸的分段线性函数h1(v)、h2(v)，使得这两个凸函数的差值为g(v)：

参考文献：
1、《Maxout  Networks》
**********************作者：hjimce   时间：2015.12.20  联系QQ：1393852684  原创文章，转载请保留原文地址、作者等信息***************
展开全文
• matlab精度检验代码Maxout Networks 该目录包含maxout单元的实现，并提供有关CIFAR-10的简单分类示例。 它基于张家仁的代码，可以找到。 安装 该模块可以与MatConvNet vl_contrib软件包管理器一起安装： vl_contrib...
• 原 深度学习（二十三）Maxout网络学习 ...


原
深度学习（二十三）Maxout网络学习

2015年12月27日 22:45:16
hjimce
阅读数 36944
更多

所属专栏：
深度学习
                        </div>
</div>
<div class="operating">
</div>
</div>
</div>
</div>
<article class="baidu_pl">
<div id="article_content" class="article_content clearfix" data-report-view="{&quot;mod&quot;:&quot;popu_307&quot;,&quot;dest&quot;:&quot;https://blog.csdn.net/hjimce/article/details/50414467&quot;}" data-report-click="{&quot;mod&quot;:&quot;popu_307&quot;,&quot;dest&quot;:&quot;https://blog.csdn.net/hjimce/article/details/50414467&quot;}" style="height: 1779px; overflow: hidden;">

版权声明：本文为博主原创文章，欢迎转载，转载请注明原文地址、作者信息。                        https://blog.csdn.net/hjimce/article/details/50414467                    </div>
<div class="htmledit_views" id="content_views">
<p style="text-align:center;"><span style="font-family:Arial;"><span style="font-size:24px;"><strong>Maxout网络学习</strong></span><br></span></p><p><span style="font-family:Arial;font-size:18px;"><strong>原文地址</strong>：<a href="http://blog.csdn.net/hjimce/article/details/50414467" rel="nofollow">http://blog.csdn.net/hjimce/article/details/50414467</a></span></p><p><span style="font-family:Arial;font-size:18px;"><strong>作者</strong>：hjimce</span></p><p><span style="font-family:Arial;font-size:18px;"><strong>一、相关理论</strong></span></p><p><span style="font-family:Arial;font-size:18px;">&nbsp; &nbsp;本篇博文主要讲解2013年，ICML上的一篇文献：《Maxout &nbsp;Networks》，这个算法我目前也很少用到，个人感觉最主要的原因应该是这个算法参数个数会成k倍增加(k是maxout的一个参数)，不过没关系，对于我们来说知识积累才是最重要的，指不定某一天我们就需要用到这个算法，技多不压身。</span><span style="font-family:Arial;font-size:18px;">个人感觉Maxout网络和Dropout有很多相似的地方。</span></p><p><span style="font-family:Arial;font-size:18px;">&nbsp; &nbsp; 本篇博文将从什么是maxout网络讲起，先解答maxout的源码层实现，因为很多人最感兴趣的还是算法要怎么实现，当然我也是这样的。我看文献，一般最在意的还是源码的实现，有的文献理论公式推导了十几页，结果5行代码搞定，我看到想哭，这也许就是我讨厌做学术研究的原因吧。知道了源码怎么实现后，我们简单啰嗦一下maxout相关的理论意义。</span></p><p></p><p><span style="font-family:Arial;font-size:18px;"><strong>二、Maxout算法流程</strong></span></p><p><span style="font-family:Arial;font-size:18px;"><strong>1、算法概述</strong></span></p><p><span style="font-family:Arial;font-size:18px;">开始前我们先讲解什么叫maxout networks，等我们明白了什么叫maxout 网络后，再对maxout的相理论意义做出解释。Maxout是深度学习网络中的一层网络，就像池化层、卷积层一样等，我们可以把maxout 看成是网络的激活函数层，这个后面再讲解，本部分我们要先知道什么是maxout。我们假设网络某一层的输入特征向量为：X=（x1,x2,……xd），也就是我们输入是d个神经元。Maxout隐藏层每个神经元的计算公式如下：</span></p><p style="text-align:center;"><span style="font-family:Arial;font-size:18px;">&nbsp;<img src="https://img-blog.csdn.net/20160102195335153?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt=""></span></p><p><span style="font-family:Arial;font-size:18px;">上面的公式就是maxout隐藏层神经元i的计算公式。其中，k就是maxout层所需要的参数了，由我们人为设定大小。就像dropout一样，也有自己的参数p(每个神经元dropout概率)，maxout的参数是k。公式中Z的计算公式为：</span></p><p style="text-align:center;"><span style="font-family:Arial;font-size:18px;">&nbsp;<img src="https://img-blog.csdn.net/20160102195353046?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt=""></span></p><p><span style="font-family:Arial;font-size:18px;">权重w是一个大小为(d,m,k)三维矩阵，b是一个大小为(m,k)的二维矩阵，这两个就是我们需要学习的参数。如果我们设定参数k=1，那么这个时候，网络就类似于以前我们所学普通的MLP网络。</span></p><p><span style="font-family:Arial;font-size:18px;">我们可以这么理解，本来传统的MLP算法在第i层到第i+1层，参数只有一组，然而现在我们不怎么干了，我们在这一层同时训练n组参数，然后选择激活值最大的作为下一层神经元的激活值。下面还是用一个例子进行讲解，比较容易搞懂。</span></p><p><span style="font-family:Arial;font-size:18px;">为了简单起见，假设我们网络第i层有2个神经元x1、x2，第i+1层的神经元个数为1个，如下图所示：</span></p><p style="text-align:center;"><span style="font-family:Arial;font-size:18px;"><img src="https://img-blog.csdn.net/20160103170530445?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt=""><br></span></p><p><span style="font-family:Arial;font-size:18px;">(1)以前MLP的方法。我们要计算第i+1层，那个神经元的激活值的时候，传统的MLP计算公式就是：</span></p><p style="text-align:center;"><span style="font-family:Arial;font-size:18px;">z=W*X+b</span></p><p style="text-align:center;"><span style="font-family:Arial;font-size:18px;">out=f(z)</span></p><p><span style="font-family:Arial;font-size:18px;">其中f就是我们所谓的激活函数，比如Sigmod、Relu、Tanh等。</span></p><p><span style="font-family:Arial;font-size:18px;">(2)Maxout 的方法。如果我们设置maxout的参数k=5，maxout层就如下所示：</span></p><p style="text-align:center;"><span style="font-family:Arial;font-size:18px;"><img src="https://img-blog.csdn.net/20160103165828920?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt=""><br></span></p><p style="text-align:left;"><span style="font-family:Arial;font-size:18px;">相当于在每个输出神经元前面又多了一层。这一层有5个神经元，此时maxout网络的输出计算公式为：</span></p><p style="text-align:center;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;">z1=w1*x+b1</span><br></span></p><p style="text-align:center;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;">z2=w2*x+b2</span><br></span></span></p><p style="text-align:center;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;">z3=w3*x+b3</span><br></span></span></span></p><p style="text-align:center;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;">z4=w4*x+b4</span><br></span></span></span></span></p><p style="text-align:center;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;">z5=w5*x+b5</span><br></span></span></span></span></span></p><p style="text-align:center;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;"><span style="font-family:Arial;font-size:18px;">out=max(z1,z2,z3,z4,z5)</span></span></span></span></span></span></p><p style="text-align:left;"><span style="font-size:18px;">所以这就是为什么采用maxout的时候，参数个数成k倍增加的原因。本来我们只需要一组参数就够了，采用maxout后，就需要有k组参数。</span></p><p><span style="font-family:Arial;font-size:18px;"><strong>三、源码实现</strong></span></p><p><span style="font-family:Arial;font-size:18px;">o</span><span style="font-size:18px;"><span style="font-family:Arial;">k，为了学习maxout源码的实现过程，我这边引用keras的源码maxout的实现，进行讲解。keras的网站为：<a href="http://keras.io/" rel="nofollow">http://keras.io/</a>&nbsp; &nbsp;。</span><span style="font-family:Arial;">项目源码网站为：</span><a href="https://github.com/fchollet/keras" rel="nofollow" style="font-family:Arial;">https://github.com/fchollet/keras</a>。下面是keras关于maxout网络层的实现函数：</span></p><p><span style="font-size:18px;"></span></p><pre><code class="hljs ruby"><ol class="hljs-ln" style="width:866px"><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="1"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"><span class="hljs-comment">#maxout 网络层类的定义</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="2"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"><span class="hljs-class"><span class="hljs-keyword">class</span> <span class="hljs-title">MaxoutDense</span>(<span class="hljs-title">Layer</span>):</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="3"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">    <span class="hljs-comment"># 网络输入数据矩阵大小为(nb_samples, input_dim)</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="4"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">    <span class="hljs-comment"># 网络输出数据矩阵大小为(nb_samples, output_dim)</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="5"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">    input_ndim = <span class="hljs-number">2</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="6"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">   <span class="hljs-comment">#nb_feature就是我们前面说的k的个数了，这个是maxout层特有的参数</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="7"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">__init__</span><span class="hljs-params"><span class="hljs-params">(<span class="hljs-keyword">self</span>, output_dim, nb_feature=<span class="hljs-number">4</span>,</span></span></span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="8"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"><span class="hljs-params">                 init=<span class="hljs-string">'glorot_uniform'</span>, weights=None,</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="9"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"><span class="hljs-params">                 W_regularizer=None, b_regularizer=None, activity_regularizer=None,</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="10"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"><span class="hljs-params">                 W_constraint=None, b_constraint=None, input_dim=None, **kwargs)</span>:</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="11"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.output_dim = output_dim</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="12"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.nb_feature = nb_feature</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="13"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.init = initializations.get(init)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="14"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="15"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.W_regularizer = regularizers.get(W_regularizer)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="16"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.b_regularizer = regularizers.get(b_regularizer)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="17"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.activity_regularizer = regularizers.get(activity_regularizer)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="18"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="19"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.W_constraint = constraints.get(W_constraint)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="20"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.b_constraint = constraints.get(b_constraint)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="21"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.constraints = [<span class="hljs-keyword">self</span>.W_constraint, <span class="hljs-keyword">self</span>.b_constraint]</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="22"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="23"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.initial_weights = weights</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="24"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.input_dim = input_dim</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="25"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">if</span> <span class="hljs-keyword">self</span>.<span class="hljs-symbol">input_dim:</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="26"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">            kwargs[<span class="hljs-string">'input_shape'</span>] = (<span class="hljs-keyword">self</span>.input_dim,)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="27"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.input = K.placeholder(ndim=<span class="hljs-number">2</span>)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="28"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">super</span>(MaxoutDense, <span class="hljs-keyword">self</span>).__init_<span class="hljs-number">_</span>(**kwargs)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="29"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">    <span class="hljs-comment">#参数初始化部分</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="30"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">build</span><span class="hljs-params">(<span class="hljs-keyword">self</span>)</span></span>:</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="31"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        input_dim = <span class="hljs-keyword">self</span>.input_shape[<span class="hljs-number">1</span>]</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="32"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="33"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.W = <span class="hljs-keyword">self</span>.init((<span class="hljs-keyword">self</span>.nb_feature, input_dim, <span class="hljs-keyword">self</span>.output_dim))<span class="hljs-comment">#nb_feature是我们上面说的k。</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="34"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.b = K.zeros((<span class="hljs-keyword">self</span>.nb_feature, <span class="hljs-keyword">self</span>.output_dim))</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="35"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="36"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.params = [<span class="hljs-keyword">self</span>.W, <span class="hljs-keyword">self</span>.b]</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="37"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">self</span>.regularizers = []</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="38"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="39"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">if</span> <span class="hljs-keyword">self</span>.<span class="hljs-symbol">W_regularizer:</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="40"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">            <span class="hljs-keyword">self</span>.W_regularizer.set_param(<span class="hljs-keyword">self</span>.W)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="41"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">            <span class="hljs-keyword">self</span>.regularizers.append(<span class="hljs-keyword">self</span>.W_regularizer)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="42"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="43"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">if</span> <span class="hljs-keyword">self</span>.<span class="hljs-symbol">b_regularizer:</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="44"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">            <span class="hljs-keyword">self</span>.b_regularizer.set_param(<span class="hljs-keyword">self</span>.b)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="45"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">            <span class="hljs-keyword">self</span>.regularizers.append(<span class="hljs-keyword">self</span>.b_regularizer)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="46"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="47"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">if</span> <span class="hljs-keyword">self</span>.<span class="hljs-symbol">activity_regularizer:</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="48"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">            <span class="hljs-keyword">self</span>.activity_regularizer.set_layer(<span class="hljs-keyword">self</span>)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="49"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">            <span class="hljs-keyword">self</span>.regularizers.append(<span class="hljs-keyword">self</span>.activity_regularizer)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="50"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="51"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">if</span> <span class="hljs-keyword">self</span>.initial_weights is <span class="hljs-keyword">not</span> <span class="hljs-symbol">None:</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="52"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">            <span class="hljs-keyword">self</span>.set_weights(<span class="hljs-keyword">self</span>.initial_weights)</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="53"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">            del <span class="hljs-keyword">self</span>.initial_weights</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="54"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line"> </div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="55"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">    <span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">get_output</span><span class="hljs-params">(<span class="hljs-keyword">self</span>, train=False)</span></span>:</div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="56"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        X = <span class="hljs-keyword">self</span>.get_input(train)<span class="hljs-comment">#需要切记这个x的大小是(nsamples,input_num) </span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="57"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-comment"># -- don't need activation since it's just linear.</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="58"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        output = K.max(K.dot(X, <span class="hljs-keyword">self</span>.W) + <span class="hljs-keyword">self</span>.b, axis=<span class="hljs-number">1</span>)<span class="hljs-comment">#maxout激活函数</span></div></div></li><li><div class="hljs-ln-numbers"><div class="hljs-ln-line hljs-ln-n" data-line-number="59"></div></div><div class="hljs-ln-code"><div class="hljs-ln-line">        <span class="hljs-keyword">return</span> output</div></div></li></ol></code><div class="hljs-button {2}" data-title="复制" onclick="hljs.copyCode(event)"></div></pre><span style="font-family:Arial;font-size:18px;">看上面的代码的话，其实只需要看get_output()函数，就知道maxout的实现了。所以说有的时候，一篇文献的代码，其实就只有几行代码，maxout就仅仅只有一行代码而已：</span><p></p><p><span style="font-family:Arial;font-size:18px;"></span></p><pre><code class="hljs swift">output = <span class="hljs-type">K</span>.<span class="hljs-built_in">max</span>(<span class="hljs-type">K</span>.dot(<span class="hljs-type">X</span>, <span class="hljs-keyword">self</span>.<span class="hljs-type">W</span>) + <span class="hljs-keyword">self</span>.b, axis=<span class="hljs-number">1</span>)#maxout激活函数</code><div class="hljs-button {2}" data-title="复制" onclick="hljs.copyCode(event)"></div></pre><p></p><p><span style="font-family:Arial;font-size:18px;">下面在简单啰嗦一下相关的理论，毕竟文献的作者写了那么多页，我们总得看一看才行。Maxout可以看成是一个激活函数&nbsp;，然而它与原来我们以前所学的激活函数又有所不同。传统的激活函数：</span></p><div style="text-align:center;"><span style="font-family:Arial;font-size:18px;"><img src="https://img-blog.csdn.net/20160102210447410?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt=""></span></div><p></p><p><span style="font-family:Arial;"><span style="font-size:18px;">比如阈值函数、S函数等。maxout激活函数，它具有如下性质：</span></span></p><p style="text-align:left;"><span style="font-family:Arial;"><span style="font-size:18px;">1、maxout激活函数并不是一个固定的函数，不像Sigmod、Relu、Tanh等函数，是一个固定的函数方程</span></span></p><p style="text-align:left;"><span style="font-family:Arial;"><span style="font-size:18px;">2、它是一个可学习的激活函数，因为我们W参数是学习变化的。</span></span></p><p style="text-align:left;"><span style="font-family:Arial;"><span style="font-size:18px;">3、它是一个分段线性函数：</span></span></p><p style="text-align:center;"><span style="font-family:Arial;"><span style="font-size:18px;"><img src="https://img-blog.csdn.net/20160102203555432?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt=""><br></span></span></p><p style="text-align:left;"><span style="font-family:Arial;"><span style="font-size:18px;">然而任何一个凸函数，都可以由线性分段函数进行逼近近似。其实我们可以把以前所学到的激活函数：relu、abs激活函数，看成是分成两段的线性函数，如下示意图所示：<br></span></span></p><div style="text-align:center;"><span style="font-family:Arial;"><span style="font-size:18px;"><img src="https://img-blog.csdn.net/20160102210809727?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt=""></span></span></div><div><span style="font-size:18px;">　maxout的拟合能力是非常强的，它可以拟合任意的的凸函数。最直观的解释就是任意的凸函数都可以由分段线性函数以任意精度拟合（学过高等数学应该能明白），而maxout又是取k个隐隐含层节点的最大值，这些”隐隐含层"节点也是线性的，所以在不同的取值范围下，最大值也可以看做是分段线性的（分段的个数与k值有关）-本段摘自：<a href="http://www.cnblogs.com/tornadomeet/p/3428843.html" rel="nofollow">http://www.cnblogs.com/tornadomeet/p/3428843.html</a><br></span></div><p></p><p style="text-align:left;"><span style="font-size:18px;"><span style="font-family:Arial;">maxout是一个函数逼近器<strong>，</strong></span><span style="font-family:Arial;">对于一个标准的MLP网络来说，如果隐藏层的神经元足够多，那么理论上我们是可以逼近任意的函数的。类似的，对于maxout 网络也是一个函数逼近器。</span></span></p><p style="text-align:left;"><span style="font-family:Arial;"><span style="font-size:18px;">定理1：对于任意的一个连续分段线性函数g(v)，我们可以找到两个凸的分段线性函数h1(v)、h2(v)，使得这两个凸函数的差值为g(v)：</span></span></p><p style="text-align:center;"><span style="font-family:Arial;"><span style="font-size:18px;"><img src="https://img-blog.csdn.net/20160103165034312?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt=""><br></span></span></p><p style="text-align:center;"><span style="font-family:Arial;"><span style="font-size:18px;"><img src="https://img-blog.csdn.net/20160103165143327?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt=""><br></span></span></p><p style="text-align:left;"><span style="font-size:18px;">参考文献：</span></p><p style="text-align:left;"><span style="font-size:18px;">1、<span style="font-family:Arial;">《Maxout &nbsp;Networks》</span></span></p><p style="text-align:left;"><span style="font-family:Arial;"><span style="font-size:18px;">2、<a href="http://www.cnblogs.com/tornadomeet/p/3428843.html" rel="nofollow">http://www.cnblogs.com/tornadomeet/p/3428843.html</a></span></span></p><p style="text-align:left;"><span style="font-size:18px;"><span style="color:rgb(51,51,51);font-family:Arial;line-height:26px;">**********************作者：hjimce &nbsp; 时间：2015.12.20 &nbsp;联系QQ：1393852684 &nbsp;</span><span style="color:rgb(51,51,51);font-family:Arial;font-size:18px;line-height:26px;">原创文章，转载请保留原文地址、作者等信息***************</span><span style="color:rgb(51,51,51);font-family:Arial;line-height:26px;"></span></span></p>                                    </div>
</div>
</article>



展开全文
• MaxOut 网络4.1 与ReLU的关系4.2 可能训练处激活函数的样子4.3 MaxOut 的训练 1 sigmoid激活函数的不足之处 在网络结构非常深的情况下，由于梯度消失问题的存在，可能会导致靠近输入附近的隐藏层的权重变化较慢，...
• Maxout网络学习原文地址：http://blog.csdn.net/hjimce/article/details/50414467作者：hjimce一、相关理论 本篇博文主要讲解2013年，ICML上的一篇文献：《Maxout Networks》，这个算法我目前也很少用到，个人感觉...
• 一 介绍Maxout网络可以理解为单个神经元的扩展，主要是扩展单个神经元里面的激活函数。Maxout是将激活函数变成一个网络选择器，原理就是将多个神经元并列地放在一起，从它们的输出结果中找到最大的那个，代表对特征...
• 用多个激活函数，取出最大的值，而不是一个激活函数（深度学习（二十三）Maxout网络学习_hjimce的专栏-CSDN博客_maxout https://blog.csdn.net/hjimce/article/details/50414467）
• ## Maxout详解

万次阅读 多人点赞 2018-09-21 11:53:35
一、相关理论  本篇博文主要讲解2013年，ICML上的一篇文献：《Maxout Networks》，这个算法我目前也很少用到，个人感觉最主要的原因应该是这...个人感觉Maxout网络和Dropout有很多相似的地方。  本篇博文将从什...
• Maxout网络学习 原文地址：http://blog.csdn.net/hjimce/article/details/50414467 作者：hjimce 一、相关理论  本篇博文主要讲解2013年，ICML上的一篇文献：《Maxout Networks》，这个算法我目前也很少用到，...
• maxout = tf . reduce_max ( z , axis = 1 , keep_dims = True ) #设置学习参数 W2 = tf . Variable ( tf . truncated_normal ( [ 1 , 10 ] , stddev = 0.1 ) ) b2 = tf . Variable ( tf . zeros ( [ 10 ]...
• 针对深度卷积神经网络maxout 单元非最大特征无法传递、特征图像子空间池化表达能力不足的局限性，提出混合maxout (mixout,mixed maxout)单元。首先，计算相同输入在不同卷积变换下所形成的特征图像子空间的指数...
• ## Maxout 论文笔记

千次阅读 2018-05-09 21:49:21
MaxoutMaxout networks ...dropout由Hinton提出的一个网络正则技术。dropout通过对共享参数的fc层的一些神经元固定概率的随机置零，来集成多个模型，并且对多个模型的预测进行了平均。dropout是一个通用技术，可...
• 在本文中，我们将maxout神经元与两个流行的DNN结构进行声学建模，即卷积神经网络（CNN）和长短期记忆（LSTM）递归神经网络（RNN）。 探索了模型的最佳网络结构和训练策略。 实验是根据IARPA Babel计划下发布的基准...
• MAXOUT神经网络及实例应用 一、maxout 神经网络的介绍 Maxout 神经网络 可以理解为单个神经元的拓展，主要是拓展单个神经元里面的激活函数。将激活函数变成一个网络选择器，原理就是将多个神经元并排的放在一起，从...
• 基于ReLU稀疏性的MAXOUT卷积神经网络的数据分类算法.pdf
• 基于混合maxout单元的卷积神经网络性能优化.pdf
• 本文先介绍两个13，14年的工作：Maxout Networks，Network In Network。网上有不少资料，但是很多作者我相信自己都没有完全理解，在本文中我会尽可能描述清楚。本文重点在于Network In Network。本文针对论文和网络...
• ## Maxout Networks

万次阅读 2016-09-13 16:28:56
单元含有任意多个“隐隐层”节点，那么只要两个隐层的maxout网络就可以实现任意连续函数的近似。 maxout网络不仅可以学习到隐层之间的关系，还可以学习到每个隐层单元的激活函数。 maxout放弃了传统激活函数的...
• 一、相关理论    本篇博文主要讲解2013年，ICML上的一篇文献：《Maxout  Networks》，这个算法我目前也很少用到，个人感觉最主要的原因应该是这...

...