pytorch(任务二)

设立计算图并自动计算
1.numpy 和pytorch 实现梯度下降法
a.设定初始值
b.求取梯度
c.在梯度方向上进行参数的更新
numpy 和实现线性回归
2.实现一个简单的神经网络

1.1numpy实现梯度下降

import numpy as np

#构造一个函数
def func(x,y):
return (1-x)2+100(y-x*2)**2

#函数对x求导
def dz_dx(x,y):
return 2x-400(y-x**2)*x-2

#函数对y求导
def dz_dy(x,y):
return 200*(y-x**2)

#梯度下降
def Grad(learinng_rate,Max_iter):
value = np.zeros(2)#构造初始值
loss = 10.0
iter_count = 0

#当自变量的变化时因变量的变化非常小时或者迭代次数没有达到最大时
while loss > 0.001 and iter_count < Max_iter:
    error = np.zeros(2)
    error[0] = dz_dx(value[0],value[1])
    error[1] = dz_dy(value[0],value[1])

    #当各自的偏导数求出来以后就需要对各自方向的值进行更新
    for i in range(2):
        value[i] = value[i]-learinng_rate*error[i]
    loss = func(value[0],value[1])
    print('迭代次数：',iter_count,'损失：',loss)
    iter_count += 1
return value

if name == ‘main’:
print(Grad(0.001,10000))

1.2pytorch 实现梯度下降法

1.需求说明

我们首先随机生成N个数，再通过一个线性函数生成目标数据target，然后将这N个数据通过我们自定义的神经网络得到输出output，通过不断迭代更新w和b，最小化target和output的差值，以此来实现：输入最初产生的随机数据N，通过网络，得到近似线性函数生成的目标数据target。

2…编程实现

import torch
from torch.autograd import Variable
import torch.nn as nn
import torch.nn.functional as f
import torch.optim as optim
import matplotlib.pyplot as plt
NUM = 100
hide_num = 300
class Net(nn.Module):
def init(self):
super(Net,self).init()

    self.fc1 = nn.Linear(NUM,hide_num)
    self.fc2 = nn.Linear(hide_num,NUM)

def forward(self,x):
    x = f.relu(self.fc1(x))
    x = self.fc2(x)
    return x

net = Net()
print(net)
for param in net.parameters():
print(param.size())
x = torch.randn(NUM)
input = Variable(x)

target = Variable(0.5 * x + 0.3)

optimizer = optim.SGD(net.parameters(),lr=0.01)
loss_list =[]
step = 500
for epoch in range(step):
optimizer.zero_grad() #参数梯度清零，因为会叠加
out = net(input)
loss = nn.MSELoss()(out,target)
loss_list.append(loss)
loss.backward()
optimizer.step()

print(‘loss 的层级--------->’)
t = loss.grad_fn
while t:
print(t)
t = t.next_functions[0][0]

print(‘target—>’,target)
out1 = net(input)
print(‘out1------>’,out1)
print(nn.MSELoss()(out1,target))

plt.figure(1)
plt.plot(range(1,NUM+1),target.detach().numpy().tolist(),’*’,ms=10,lw=1,color=‘black’) #question:detach()
plt.plot(range(1,NUM+1),out1.detach().numpy().tolist(),‘o’,ms=3,lw=1,color=‘red’)
plt.show()
plt.figure(2)
plt.plot(range(1,step+1),loss_list,‘o-’,ms=3,lw=1,color=‘black’)
plt.show()

2.实现一个简单的神经网络

实现一个四层的神经网络

import numpy as np1

//定义一个激活函数
def sigmoid(x,deriv=False):
if (deriv == True):
return x*(1-x)
return 1/(1+np.exp(-x))12345

//构造样本
X = np.array([
[1,0,1,0,1,1],
[1,1,1,0,1,1],
[1,0,1,0,0,1],
[1,0,0,0,0,1],
[1,1,1,1,1,1],
[0,0,1,0,1,0],
[0,0,1,1,1,1]
])12345678910

//构造标签
y = np.array([
[1],
[0],
[0],
[1],
[1],
[1],
[0]
])12345678910

//设定一个种子
np.random.seed(1)12

//随机化初始权重值，高斯初始化，或者随机0-1初始化
w0 = 2np.random.random((6,5))
w1 = 2np.random.random((5,7))
w2 = 2*np.random.random((7,1))1234

//构造网络，这里迭代6000次
for i in range(60000):
# 前向传播
L0 = X
L1 = sigmoid(L0.dot(w0))
L2 = sigmoid(L1.dot(w1))
L3 = sigmoid(L2.dot(w2))
#计算错误
L3_error = L3 - y
if(i%10000 == 0): #每10000次打印出来一个error
print("Error: "+np.str(np.mean(np.abs(L3_error))))
#进行反向传播
L3_delta = L3_error * sigmoid(L3,deriv = True)

L2_error = L3_delta.dot(w2.T)
L2_delta = L2_error * sigmoid(L2,deriv = True)

L1_error = L2_delta.dot(w1.T)
L1_delta = L1_error * sigmoid(L1,deriv = True)

L0_error = L1_delta.dot(w0.T)
L0_delta = L0_error * sigmoid(L0,deriv = True)

#更新梯度
w2 -= L2.T.dot(L3_delta)
w1 -= L1.T.dot(L2_delta)
w0 -= L0.T.dot(L1_delta)

print(w2)
print(w1)
print(w0)!