mlp是啥啊(mlp是什么)

这就是mlp的意义所在。让我一开始就告诉自己一件事。Nerf使用最快的relu激活，因为relu不存在梯度消失的现象，所以速度很快。

至于这个现象的解释请看下图：

好吧，我们开始讨论MLP。MLP实际上是具有多层神经网络的所谓多层感知器。感知器用于分类。

从上图可以看出，mlp最大的作用就是实现非线性分类。之所以能够进行非线性分类，是因为这个隐藏层进行了空间变换，这就是我在之前的博客中所说的，要想实现非线性，就必须进行运算。

MLP有很多缺点。其中之一是速度慢。难怪纳夫跑得这么慢。下面是从别人博客转载的MLP代码：

from__future__importprint_function,除法

将numpy导入为np

导入数学

从sklearn导入数据集

从mlfromscratch.utils导入train_test_split、to_categorical、标准化、accuracy_score、绘图

从mlfromscratch.deep_learning.activation_functions导入Sigmoid、Softmax

从mlfromscratch.deep_learning.loss_functions导入CrossEntropy

多层感知器类():

'''多层感知器分类器。一种具有一个隐藏层的全连接神经网络。

展开以显示整个前向和后向传递。

参数：

----------

n_hidden:int:

隐藏层中处理节点的数量。

n_iterations:浮点数

算法将调整权重的训练迭代次数。

Learning_rate:浮动

更新权重时将使用的步长。

'''

def__init__(自我，n_hidden，n_iterations=3000，learning_rate=0.01):

self.n_hidden=n_hidden

self.n_iterations=n_iterations

自我学习率=学习率

self.hidden_activation=Sigmoid()

self.output_activation=Softmax()

self.loss=CrossEntropy()

def_initialize_weights:

n_samples,n_features=X.shape

_,n_outputs=y.shape

#隐藏层

限制=1/math.sqrt(n_features)

self.W=np.random.uniform(-limit,limit,(n_features,self.n_hidden))

self.w0=np.zeros((1,self.n_hidden))

#输出层

limit=1/math.sqrt(self.n_hidden)

self.V=np.random.uniform(-limit,limit,(self.n_hidden,n_outputs))

self.v0=np.zeros((1,n_outputs))

deffit(自身，X，y):

self._initialize_weights(X,y)

对于范围内的i(self.n_iterations):

#…………

#ForwardPass

#…………

#隐藏层

隐藏输入=X.dot(self.W)+self.w0

隐藏输出=self.隐藏激活

#输出层

输出层输入=隐藏输出.dot(self.V)+self.v0

y_pd=self.output_activation(output_layer_input)

#...

#向后传递

#...

#输出层

#毕业。w.r.t输出层的输入

grad_wrt_out_l_input=self.loss.gradient(y,y_pd)*self.output_activation.gradient(output_layer_input)

grad_v=hide_output.T.dot(grad_wrt_out_l_input)

grad_v0=np.sum(grad_wrt_out_l_input,axis=0,keepdims=True)

#隐藏层

#毕业。隐藏层的w.r.t输入

grad_wrt_hidden_l_input=grad_wrt_out_l_input.dot(self.V.T)*self.hidden_activation.gradient(hidden_input)

grad_w=X.T.dot(grad_wrt_hidden_l_input)

grad_w0=np.sum(grad_wrt_hidden_l_input,axis=0,keepdims=True)

#更新权重

#逆梯度移动以最小化损失

self.V-=self.learning_rate*grad_v

self.v0-=self.learning_rate*grad_v0

self.W-=self.learning_rate*grad_w

self.w0-=self.learning_rate*grad_w0

#使用训练好的模型来预测X的标签

defpdict(self,X):

#转发：

隐藏输入=X.dot(self.W)+self.w0

隐藏输出=self.隐藏激活

输出层输入=隐藏输出.dot(self.V)+self.v0

y_pd=self.output_activation(output_layer_input)

返回y_pd

defmain():

数据=datasets.load_digits()

X=标准化(数据.数据)

y=数据.目标

#将名义y值转换为二进制

y=to_categorical(y)

X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.4,种子=1)

#MLP

clf=多层感知器(n_hidden=16,

n_迭代=1000，

学习率=0.01）

clf.fit(X_train,y_train)

y_pd=np.argmax(clf.pdict(X_test),axis=1)

y_test=np.argmax(y_test,轴=1)

准确度=准确度_分数

print('Accuracy:',准确度)

#使用PCA将维度降为2并绘制结果

Plot().plot_in_2d(X_test,y_pd,title='多层感知器',precision=accuracy,legend_labels=np.unique(y))

如果__name__=='__main__':

主要的

这里的隐藏层是一个全连接层，因为隐藏层必须改变的空间，意味着这一层的所有神经元都与上一层相连。根据每个神经元的参数不同，全连接层的作用自然也不同）。卷积用于分类。

这里全连接层的神经元是激活函数经过全连接层再经过激活函数处理，用处就是利用激活函数来判断是否激活某个条件，我看到Alexnet用的是relu激活data。我想可能是因为它是非饱和的，取值范围比较大。是的，但是relu似乎在梯度下降方面表现不错，所以我们暂时忽略这个））。

如果上一层的神经元和权重的组合达到一定的条件，那么本层的某些神经元就会被激活，而最终的输出层只需要把这些激活的东西放进去就可以了一起看看它们是什么。

有人告诉我，如果全连接的输出维度比输入维度小，是为了更好的拟合。我认为这是有道理的，因为它减少了输入的原始特征。它们只能被迫组合，因此必须得出一个组合产品。称其为合适也是正常的。放一个转载的连接层代码，方便理解：

将torch.nn导入为nn

导入torch.nn.function作为F

类Net(nn.Module):

def__init__(self):

#nn.Module子类函数必须在构造函数中执行父类的构造函数

#下面的公式等价于nn.Module.__init__(self)

超级.__init__()

#卷积层“1”表示输入图像是单通道，“6”表示输出通道数，“5”表示卷积核为5*5

self.conv1=nn.Conv2d(1,6,5)

#卷积层

self.conv2=nn.Conv2d(6,16,5)

#全连接层，y=Wx+b

self.fc1=nn.Linear(16*5*5,120)

#参考第3节，这里第一层的kernel大小是前一个卷积层的输出，kernel大小为16*5*5，总共120层

self.fc2=nn.Linear(120,84)

#后续各层的内核大小为1*1

self.fc3=nn.Linear(84,10)

def前进:

#卷积--激活--池化

x=F.max_pool2d(F.relu(self.conv1(x)),(2,2))

x=F.max_pool2d(F.relu(self.conv2(x)),2)

#reshape,'-1'表示自适应

x=x.view(x.size()[0],-1)

x=F.relu(self.fc1(x))

x=F.relu(self.fc2(x))

x=自我.fc3

返回x

净=净()

打印

我想我应该把这些功能的特点列出来，以便我以后能够了解它们各自的功能。