pytorch3-线性回归_2_pytorch线性回归二元一次方程-优快云博客

线性回归简单实现

上次我们讲到了线性回归的表示方法，并通过一个二元一次方程简单的手动实现了线性回归的方法，这次我们调用相关的接口，实现下这个二元一次方程的回归。

import torch
from IPython import display
from matplotlib import pyplot as plt
import numpy as np
import random
import torch.tuils.data as Data


# 生成数据集
num_inputs = 2
num_examples = 1000
true_w = [2, -3.4]
true_b = 4.2
features = torch.tensor(np.random.normal(0, 1, (num_examples,
num_inputs)), dtype=torch.float)
labels = true_w[0] * features[:, 0] + true_w[1] * features[:, 1] +
true_b
labels += torch.tensor(np.random.normal(0, 0.01,
size=labels.size()), dtype=torch.float)
import torch.utils.data as Data
batch_size = 10
# 将训练数据的特征和标签组合
dataset = Data.TensorDataset(features, labels)
# 随机读取⼩小批量量
data_iter = Data.DataLoader(dataset, batch_size, shuffle=True)

for X, y in data_iter:
	print(X, y)
	break

class LinearNet(nn.Module):
	def __init__(self, n_feature):
		super(LinearNet, self).__init__()
		self.linear = nn.Linear(n_feature, 1)
	# forward 定义前向传播
	def forward(self, x):
		y = self.linear(x)
		return y
net = LinearNet(num_inputs)
print(net) # 使⽤用print可以打印出⽹网络的结构

# 我们可以使用nn.Sequential来更加方便的搭建网络，Sequential是一个有序的容器，网络传入Sequential的顺序依次被添加到计算图中。
# 写法一
net=nn.Sequential(
	nn.Linear(num_input,1)
	# 此处还可以传入其他层
	)
# 写法⼆二
net = nn.Sequential()
net.add_module('linear', nn.Linear(num_inputs, 1))
# net.add_module ......
# 写法三
from collections import OrderedDict
net = nn.Sequential(OrderedDict([
		('linear', nn.Linear(num_inputs, 1))
		# ......
]))
print(net)
print(net[0])

for param in net.parameters():
	print(param)
# '''
Parameter containing:
tensor([[-0.0277, 0.2771]], requires_grad=True)
Parameter containing:
tensor([0.3395], requires_grad=True)
'''

初始化模型

from torch.nn import init
init.normal_(net[0].weight,mean=0,std=0.01)
init.constant_(net[0].bias,val=0) #也可以直接修改bias的data
net[0].bias.data.fill_(0)

定义损失函数

loss=nn.MSELoss()

定义优化算法

import torch.optim as optim
optimizer=optim.SGD(net.parameters(),lr=0.03)
print(optimizer)

'''
输出：
SGD (
Parameter Group 0
dampening: 0
lr: 0.03
momentum: 0
nesterov: False
weight_decay: 0
)
'''

我们还可以为不同的子网络设置不同的学习率，这在finetune时经常用到。例如：

optimizer=optim.SGD(
			# 如果对某个参数不不指定学习率，就使⽤用最外层的默认学习率
			{'params': net.subnet1.parameters()}, # lr=0.03
			{'params': net.subnet2.parameters(), 'lr': 0.01}
], lr=0.03)
# 有时候我们不想让学习率固定成一个常数，一种做法就是修改optimizer.param_groups中对应的学习率
# 调整学习率
for param_group in optimizer.param_groups:
		param_group['lr'] *= 0.1 # 学习率为之前的0.1倍

训练模型

num_epochs=3
for epoch in range(1,num_epochs+1):
	for X,y in data_iter:
		output = net(X)
		l = loss(output, y.view(-1, 1))
		optimizer.zero_grad() # 梯度清零，等价于net.zero_grad()
		l.backward()
		optimizer.step()
	print('epoch %d, loss: %f' % (epoch, l.item()))

下面我们看下需到的模型参数

dense = net[0]
print(true_w, dense.weight)
print(true_b, dense.bias)