Pytorch—线性模型实现_pytorch linear 实现-优快云博客

本文链接：https://blog.youkuaiyun.com/hei653779919/article/details/106631191

Pytorch—线性模型实现

本文将通过设置变量的自动求导方式来手动编写一个线性模型和利用Pytorch自定义的线性层来实现一个线性模型。

1. 手动编写

#encoding=utf-8

import torch
from IPython import display
from matplotlib import pyplot as plt
import numpy as np
import random

# 生成数据集
input_dim = 2
exmples_num = 1000
true_w = [2,-3.4]
true_b = 4.2
features = torch.randn(exmples_num,input_dim,dtype=torch.float32)
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.float32)

# 图形展示
def use_svg_display():
    display.set_matplotlib_formats('svg')
# 设置尺寸
def set_figsize(figsize=(3.5,2.5)):
    use_svg_display()
    plt.rcParams['figure.figsize'] = figsize

# 定义数据读取函数，返回一个batch的数据和对应的label值
def data_iter(batch_size,features,labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    random.shuffle(indices) 
    for i in range(0,num_examples,batch_size):
        j = torch.LongTensor(indices[i:min(i+batch_size,num_examples)])
        #index_select(0,j) 0表示按照行进行搜索，其中搜索出来的行为tensor j中定义的行
        yield features.index_select(0,j),labels.index_select(0,j)

# 定义batch的大小,生成初始化的参数
batch_size = 10
w = torch.tensor(np.random.normal(0,0.01,(input_dim,1)),dtype=torch.float32)
b = torch.zeros(1,dtype=torch.float32)

# 保证参数是可以进行求导的（需要用导数来进行更新）
w.requires_grad_(requires_grad=True)
b.requires_grad_(requires_grad=True)

# 定义线性模型
def linreg(X,w,b):
    return torch.mm(X,w) + b

#定义损失函数
def squared_loss(y_hat,y):
    return (y_hat - y.view(y_hat.size())) ** 2 / 2

#定义优化算法
def sgd(params,lr,batch_size):
    for param in params:
        param.data -= lr * param.grad / batch_size

#定义相关的超参数
lr = 0.03
num_epochs = 3
net = linreg
loss = squared_loss

if __name__ == '__main__':
	#定义训练过程	
    for epoch in range(num_epochs):
        for X,y in data_iter(batch_size,features,labels):
            loss_value = loss(net(X,w,b),y).sum()
            loss_value.backward()
            sgd([w,b],lr,batch_size)
            w.grad.data.zero_()
            b.grad.data.zero_()
        train_loss = loss(net(features,w,b),labels)
        print("epoch %d. loss %f" %(epoch+1,train_loss.mean().item()))
    print(true_w," VS ",w.tolist())
    print(true_b," VS ",b.tolist())

2 利用pytorch定义的线性层

#encoding = utf-8
import torch
import torch.nn as nn
import torch.utils.data as Data
import numpy as np
from torch.nn import init
import torch.optim as optim

#生成数据
# 生成数据集
input_dim = 2
exmples_num = 1000
true_w = [2,-3.4]
true_b = 4.2
features = torch.randn(exmples_num,input_dim,dtype=torch.float32)
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.float32)

# 利用数据加载器来自动的加载数据
batch_size = 10
dataset = Data.TensorDataset(features,labels)
data_iter = Data.DataLoader(dataset,batch_size,shuffle=True)

# 定义模型
class linear(nn.Module):
    def __init__(self,input_dim):
        super(linear,self).__init__()
        self.li = nn.Linear(input_dim,1)
    def forward(self,x):
        y = self.li(x)
        return y

if __name__ == '__main__':
    #定义模型
    net = linear(input_dim)
    init.normal_(net.li.weight,mean=0,std=0.01)
    init.constant_(net.li.bias,val=0)

    #定义损失函数
    loss = nn.MSELoss()

    # 定义优化器
    optimzer = optim.SGD(net.parameters(),lr=0.03)

    num_epochs = 3
    for epoch in range(1,num_epochs+1):
        for X,y in data_iter:
            output = net(X)
            loss_value = loss(output,y.view(-1,1))
            optimzer.zero_grad()
            loss_value.backward()
            optimzer.step()
        print("epoch %d . loss: %f" %(epoch,loss_value.item()))

在这个部分中，我们重点介绍的是 Pytorch中的处理模块torch.utils.data。

torch.utils.data.DataLoader(data_tensor,target_tensor) 将数据进行包装
参数data_tensor：需要被包装的数据。
参数target_tensor：需要被包装的label
torch.utils.data.DataLoader(dataset, batch_size=1, shuffle=False, sampler=None, num_workers=0, collate_fn=, pin_memory=False, drop_last=False)定义数据加载器。
参数dataset：通过包装其包装的数据集。
参数batch_size：定义batch的大小。
参数shuffle：是否对数据进行打乱。
参数sampler：定义采样器
参数num_workers：用多少个子进程来加载数据。
参数drop_last：如果数据集的大小不能够被batch_size整除，则设置为True之后可以删除最后一个不完整的batch。如果为False，则最后一个batch的大小不到我们提起设定的batch_size大小。
最后生成一个迭代器的结果。

进一步，我们要介绍的是如何利用pytorch建立容器，在容器内部添加网络层。

# 写法一
net = nn.Sequential(
    nn.Linear(num_inputs, 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])

容器网网络建立的方式如上图所示。

基本类 nn.Sequential()
这是一个时序的网络容器，其传入的方式包括逐层添加，如上述的写法一和写法二。另外一种传入的方式是传入OrderedDict（有序的词典，从collections进行引入）
可以通过net.parameters() 来查看所有的可以学习的参数，这是参数返回一个生成器。

for param in net.parameters():
	print(param) # 输出每一个层的参数

对于容器内的参数进行初始化的过程 torch.nn.init
以某种方式对网络的参数进行初始化，常见的包括以下几种方式
nn.init.uniform(tensor,a=0,b=1) 使用均匀分布的方式进行初始化。ab表示上界和下界
nn.init.normal(w) :使用正太分布的方式进行初始化
nn.init.constant(tensor,val) : 使用自定义常数的方式对于tensor内部的值进行填充。
在利用init对于sequential进行填充的时候，一般使用for循环，对容器中的每一个网络进行初始化。

for i in range(num_layers):
	init.normal_(net[i].weight,mean=0,std=0.01) # mean：均值 std：标准差
	init.constant_(net[i].bias,vla=0)

3. 总结

在上面的文章中，我们以线性模型的实现来描述Pytorch 如何实现线性模型，其中重点关注的了数据的加载，容器搭建已经参数的初始化模模块。

4. 参考

动手学深度学习（Pytorch版）
Pytorch 官方文档。