由一个关系拟合拓展的

import torch

import torch.nn.functional as F #激励函数，relu,sigmoid, tanh, softplus

import matplotlib.pyplot as plt

from torch.autograd import Variable

Sigmoid函数的表达式为y=1/(1+ex)。

Sigmoid函数是传统神经网络中最常用的激活函数，一度被视为神经网络的核心所在。

从数学上来看，Sigmoid函数对中央区的信号增益较大，对两侧区的信号增益小，在信号的特征空间映射上，有很好的效果。

从神经科学上来看，中央区酷似神经元的兴奋态，两侧区酷似神经元的抑制态，因而在神经网络学习方面，可以将重点特征推向中央区，将非重点特征推向两侧区。

TanHyperbolic(tanh)函数又称作双曲正切函数，数学表达式为y=(ex−e−x)/(ex+e−x)。

在具体应用中，tanh函数相比于Sigmoid函数往往更具有优越性，这主要是因为Sigmoid函数在输入处于[-1,1]之间时，函数值变化敏感，一旦接近或者超出区间就失去敏感性，处于饱和状态，影响神经网络预测的精度值。而tanh的输出和输入能够保持非线性单调上升和下降关系，符合BP网络的梯度求解，容错性好，有界，渐进于0、1，符合人脑神经饱和的规律，但比sigmoid函数延迟了饱和期。

ReLu函数的全称为Rectified Linear Units，函数表达式为y=max(0,x)，softplus函数的数学表达式为y=log(1+ex)。

softplus可以看作是ReLu的平滑。根据神经科学家的相关研究，softplus和ReLu与脑神经元激活频率函数有神似的地方。也就是说，相比于早期的激活函数，softplus和ReLu更加接近脑神经元的激活模型，而神经网络正是基于脑神经科学发展而来，这两个激活函数的应用促成了神经网络研究的新浪潮。

那么softplus和ReLu相比于Sigmoid的优点在哪里呢？

第一，采用sigmoid等函数，算激活函数时（指数运算），计算量大，反向传播求误差梯度时，求导涉及除法，计算量相对大，而采用Relu激活函数，整个过程的计算量节省很多。

第二，对于深层网络，sigmoid函数反向传播时，很容易就会出现梯度消失的情况（在sigmoid接近饱和区时，变换太缓慢，导数趋于0，这种情况会造成信息丢失），从而无法完成深层网络的训练。

第三，Relu会使一部分神经元的输出为0，这样就造成了网络的稀疏性，并且减少了参数的相互依存关系，缓解了过拟合问题的发生。

softmax函数

我们可以看到，Sigmoid函数实际上就是把数据映射到一个(−1,1)的空间上，也就是说，Sigmoid函数如果用来分类的话，只能进行二分类，而这里的softmax函数可以看做是Sigmoid函数的一般化，可以进行多分类。softmax函数的函数表达式为：σ(z)j=eZj/∑Kk=1eZk。从公式中可以看出，就是如果某一个zj大过其他z,那这个映射的分量就逼近于1,其他就逼近于0，即用于多分类。也可以理解为将K维向量映射为另外一种K维向量。

# 生成数据

x = torch.unsqueeze(torch.linspace(-1, 1,100), dim = 1)

y = x.pow(2) + 0.2 * torch.rand(x.size())

 

# 变为Variable, Variable 就是一个存放会变化的值的位置

# 定义tensor: tensor =torch.FloatTensor([[1,2],[3,4]])

# 将tensor放入Variable:variable = Variable(tensor, requires_grad=True)

#  requires_grad 是参不参与误差反向传播, 要不要计算梯度

x,y = Variable(x), Variable(y)

# 绘制数据图像

plt.scatter(x.data.numpy(), y.data.numpy())

plt.show()

 

# 定义pytorch网络，__init__只是定义了几个层，forward进行传播，也就是整个网络的搭建，因为是预测，最后一层不需要激励函数

class Net(torch.nn.Module):

 

   def __init__(self, n_features, n_hidden, n_output):

       super(Net, self).__init__()

       self.hidden = torch.nn.Linear(n_features, n_hidden)

       self.predict = torch.nn.Linear(n_hidden, n_output)

 

   def forward(self, x):

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

       y = self.predict(x)

       return y

 

# 构建网络

net = Net(1, 10, 1)

print net

 

#SGD，随机梯度下降；momentum，动量加速；RMSprop，指定参数alpha；Adam，参数betas

#opt_SGD  = torch.optim.SGD(net_SGD.parameters(), lr=LR)

#opt_Momentum  =  torch.optim.SGD(net_Momentum.parameters(),lr=LR, momentum=0.8)

#opt_RMSprop  = torch.optim.RMSprop(net_RMSprop.parameters(), lr=LR, alpha=0.9)

#opt_Adam   = torch.optim.Adam(net_Adam.parameters(), lr=LR, betas=(0.9, 0.99))

# 定义优化器，选择优化方法，传入 net 的所有参数, 学习率lr

optimizer = torch.optim.SGD(net.parameters(),lr = 0.5)

 

# 选择损失函数，# 预测值和真实值的误差计算公式 (均方差)

loss_func = torch.nn.MSELoss()

 

plt.ion()

# 训练

for i in xrange(100):

    #喂给 net 训练数据 x,对x进行预测，输出预测值

   prediction = net(x)

    #计算损失

   loss = loss_func(prediction, y)

    #每次迭代清空上一次的梯度

   optimizer.zero_grad()

    #反向传播，计算参数更新值

   loss.backward()

    #更新梯度，将参数更新值施加到 net 的 parameters 上

   optimizer.step()

 

   if i % 5 == 0:

       plt.cla()

       plt.scatter(x.data.numpy(), y.data.numpy())

       plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw = 5)

       plt.text(0.5, 0, 'Loss=%.4f' % loss.data[0], fontdict={'size': 10,'color':  'red'})

       plt.pause(0.1)

plt.ioff()

plt.show()