《PyTorch深度学习实践》课上代码笔记 一

自学笔记

课程老师：刘二大人 河北工业大学教师 https://liuii.github.io
课程来源：https://www.bilibili.com/video/BV1Y7411d7Ys

一、Gradient Descent梯度下降(无反馈)

#梯度下降的线性拟合过程，梯度使用的是平均梯度
#导入数据
x_data = [1,2,3]
y_data = [2,4,6]

#初始化w的值
w = 1

#正向传递函数
def forward(x):
	return x*w

#计算损失函数
def cost(xs,ys):
	cost = 0
	for x,y in zip(xs,ys):
		y_pred = forward(x)
		cost += (y_pred - y)**2
	return cost/len(xs)

#计算梯度
def gradient(xs,ys):
	grad = 0
	for x,y in zip(xs,ys):
		grad = 2*x*(x*w - y)
	return grad/len(xs)

#训练
#确定训练次数
for epoch in range(100):
	#计算损失
	cost_val = cost(x_data,y_data)
	#计算梯度
	grad_val = gradient(x_data,y_data)
	#更新参数w
	w -= 0.01*grad_val
	#输出每次的结果
	print("循环次数:"+str(epoch)+"+++++   w的值："+str(w))

#输出训练结果
print("pred:w=",w,forward(w))

二、Stochastic Gradient Descent随机梯度下降(无反馈)

#随机梯度下降SGD
#导入数据
x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]
#确定初始值
w = 1

#正向传递函数
def forward(x):
	return x*w

#计算损失
def loss(x,y):
	y_pred = forward(x)
	return (y_pred - y)**2

#计算梯度
def gradient(x,y):
	return 2*x*(x*w - y)

#训练
#确定训练次数
for epoch in range(100):
	#导入数据
	for x,y in zip(x_data,y_data):
		#计算梯度
		grad_val = gradient(x,y)
		#更新参数，每一个x,y即计算一次梯度，更新一次w参数值，并非使用平均梯度
		w -= 0.01*grad_val
		print("循环次数:"+str(epoch)+"+++++   w的值："+str(w))
		#损失计算
		l = loss(x,y)

#结果输出
print("pred:w=",w,forward(w),l)

三、使用pytorch(有反馈)

#使用torch完成随机梯度下降
#导入torch包
import torch
#导入数据
x_data = [1.0,2.0,3.0]
y_data = [2.0,4.0,6.0]
#初始化参数，使用Tensor(torch中的张量)
w = torch.Tensor([1.0])
#设置w的需要求导属性
w.requires_grad = True

#正向传递函数
def forward(x):
	return w*x

#定义损失函数
def loss(x,y):
	y_pred = forward(x)
	return (y - y_pred)**2

#训练
#确定训练次数
for epoch in range(100):
	for x,y in zip(x_data,y_data):
		l = loss(x,y)
		l.backward()
		w.data -= 0.01*w.grad.data
		w.grad.data.zero_()
	print("progress:",epoch,l.item())

print("predict (after training)", 4, forward(4).item())

四、线性回归，使用torch.nn类

#使用torch的线性模型训练模型
#导入包
import torch
#创建Tensor数据
x_data = torch.Tensor([[1.0],[2.0],[3.0]])
y_data = torch.Tensor([[2.0],[4.0],[6.0]])

#编写自己的类，继承自torch.nn.Module
class LinearModel(torch.nn.Module):
	#初始化
	def __init__(self):
		#继承父类的属性
		super(LinearModel,self).__init__()
		#创建自己的线性模型参数
		self.linear = torch.nn.Linear(1,1)
	#正向传播函数
	def forward(self,x):
		y_pred = self.linear(x)
		return y_pred

#实例化
model = LinearModel()
#计算损失，同样继承自torch.nn
criterion = torch.nn.MSELoss(size_average=Flase)
#使用的优化方法
optimizer = torch.optim.SGD(model.parameters(),lr=0.01)

#训练
#确定训练次数
for epoch in range(1000):
	#预测
	y_pred = model(x_data)
	#损失计算
	loss = criterion(y_pred,y_data)

	#梯度归零，每次优化时，都要手动将梯度归零
	optimizer.zero_grad()
	#损失的反馈传播
	loss.backward()
	#更新参数
	optimizer.step()

#输出
print('w = ', model.linear.weight.item())
print('b = ', model.linear.bias.item())

#测试
x_test = torch.Tensor([[4.0]])
y_test = model(x_test)
print(y_test.data)