【python】tensorflow和pytorch神经网络一元二次函数拟合

目录

一、在TensorFlow中，首先定义

二、统一的任务，pytorch来实现一下

---

先看下要做的内容，创建一元二次函数y=x平方-0.5，其中为了更符合散点图模拟需要，在方程加噪点，以标准方差0.05行驶，如图所示

折线图

散点图

下面我们要做的，是要计算机自动拟合出该散点图的函数，画出图样，如图

下面，就通过TensorFlow来看如何做出这个样子

一、在TensorFlow中，首先定义

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

#定义隐藏层
def add_layer(inputs,in_size,out_size,activation_function=None):
    Weights=tf.Variable(tf.random_normal([in_size,out_size]))  #权值
    biases=tf.Variable(tf.zeros([1,out_size])+0.1) #偏置
    Wx_plus_b=tf.matmul(inputs,Weights)+biases  #z=wx+b
    if activation_function is None:
        outputs=Wx_plus_b
    else:
        outputs=activation_function(Wx_plus_b)
    return outputs

#make up some real data
x_data=np.linspace(-1,1,300)[:,np.newaxis]#加维度
noise=np.random.normal(0,0.05,x_data.shape)#加噪点，标准方差0.05
y_data=np.square(x_data)-0.5+noise    #y=square(x)-0.5+noise

#train_step所要输入的值
xs=tf.placeholder(tf.float32,[None,1])
ys=tf.placeholder(tf.float32,[None,1])
###建立第一,二次隐藏层layer
###add_layer(inputs,in_size,out_size,activation_function=None)
l1=add_layer(xs,1,10,activation_function=tf.nn.relu)#激励函数(activation_function)ReLU
prediction=add_layer(l1,10,1,activation_function=None)

#创建损失函数
loss=tf.reduce_mean(tf.reduce_sum(tf.square(ys-prediction),
               reduction_indices=[1]))
train_step=tf.train.GradientDescentOptimizer(0.1).minimize(loss)#梯度下降优化器,减少误差，学习效率0.1

#important step
init=tf.initialize_all_variables()
sess=tf.Session()
sess.run(init)

#绘图部分
fig=plt.figure()
ax=fig.add_subplot(1,1,1)
ax.scatter(x_data,y_data)
plt.ion()#不暂停
plt.show()

#学习1000步
for i in range(1000):
    sess.run(train_step,feed_dict={xs:x_data,ys:y_data})
    if i%50==0:
        #print(sess.run(loss,feed_dict={xs:x_data,ys:y_data})) #输出误差
        try:
            ax.lines.remove(lines[0])
        except Exception:
            pass
            
        prediction_value=sess.run(prediction,feed_dict={xs:x_data})
        lines=ax.plot(x_data,prediction_value,'r',lw=5)
        plt.pause(0.1)

输出误差截图，每50次输出一次，截图如下

 

误差逐渐递减的截图

这样就完成了

二、统一的任务，pytorch来实现一下

import torch
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pylab as plt

x=torch.unsqueeze(torch.linspace(-1,1,100),dim=1)   #dim=0列 dim=1行   （100,1）
y=x.pow(2)+0.2*torch.rand(x.size())  #pow平方

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

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

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)

##可视化,实时打印
plt.ioff()
plt.show()

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

for t in range(100):
    prediction=net(x)

    loss=loss_func(prediction,y)

    #优化步骤
    optimizer.zero_grad()####每次循环，梯度都先设为0
    loss.backward()
    optimizer.step()

    if t%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.numpy(),fontdict={'size':20,'color':'red'})
        plt.pause(0.1)

plt.ioff()
plt.show()