pyTorch基础入门（附代码）

故里_

已于 2022-04-22 19:40:25 修改

阅读量3.1k

点赞数 1

分类专栏： PyTorch 文章标签： pytorch 学习深度学习

于 2022-03-16 11:00:22 首次发布

本文链接：https://blog.csdn.net/lht0909/article/details/123517959

版权

PyTorch 专栏收录该内容

6 篇文章 3 订阅

订阅专栏

编辑器：jupyter
pytorch的安装网址：https://pytorch.org/
建议使用pip安装方式，安装版本分为CPU和GPU 在这里插入图片描述
pytorch的一些基本操作
torch.FloatTensor用于生成数据类型为浮点型的Tensor，传递给torch.FloatTensor的参数可以是列表，也可以是一个维度值。

torch.IntTensor用于生成数据类型为整型的Tensor,传递给传递给torch.IntTensor的参数可以是列表，也可以是一个维度值。
在这里插入图片描述
torch.randn
用于生成数据类型为浮点数且维度指定的随机Tensor，和在numpy中使用的numpy.randn生成的随机数的方法类似，随机生成的浮点数的取值满足均值为0，方差为1的正态分布。

torch.range用于生成数据类型为浮点型且起始范围和结束范围的Tensor，所以传递给torch.range的参数有三个，分别为起始值，结束值，步长，其中步长用于指定从起始值到结束值得每步的数据间隔。
在这里插入图片描述
torch.zeros用于生成数据类型为浮点型且维度指定的Tensor，不过这个浮点型的Tensor中的元素值全部为0。

torch.ones生成全1的数组。

torch.empty创建一个未被初始化数值的tensor,tensor的大小是由size确定,size: 定义tensor的shape ，这里可以是一个list 也可以是一个tuple
在这里插入图片描述

Tensor的运算
将参数传递到torch.abs后返回输入参数的绝对值作为输出，输入参数必须是一个Tensor数据类型的变量

将参数传递到torch.add后返回输入参数的求和结果作为输出，输入参数既可以全部是Tensor数据类型的变量，也可以一个是Tensor数据类型的变量，另一个是标量
在这里插入图片描述
rch.clamp是对输入参数按照自定义的范围进行裁剪，最后将参数裁剪的结果作为输出，所以输入参数一共有三个，分别是需要进行裁剪的Tensor数据类型的变量、裁剪的上上边界和裁剪的下边界

torch.div是将参数传递到torch.div后返回输入参数的求商结果作为输出，同样，参与运算的参数可以全部是Tensor数据类型的变量，也可以是Tensor数据类型的变量和标量的组合。
在这里插入图片描述
torch.pow：将参数传递到torch.pow后返回输入参数的求幂结果作为输出，参与运算的参数可以全部是Tensor数据类型的变量，也可以是Tensor数据类型的变量和标量的组合。

torch.mm：将参数传递到torch.mm后返回输入参数的求积结果作为输出
在这里插入图片描述
将参数传递到torch.mv后返回输入参数的求积结果作为输出，torch.mv运用矩阵与向量之间的乘法规则进行计算，被传入的第1个参数代表矩阵，第2个参数代表向量，循序不能颠倒。

在这里插入图片描述

#框架干的最厉害的一件事就是帮我们把反向传播全部计算好
#需要求导的可以手动定义梯度的求法即是对要求梯度的参数求偏导。必须设置requires_grad=True才能求梯度。
#方法一
import torch
x=torch.randn(3,4,requires_grad=True)#使用[0,1]均匀分布随机初始化二维数组

在这里插入图片描述

#方法二
x=torch.randn(3,4)
x.requires_grad=True

在这里插入图片描述
Variable可简单封装Tensor，支持几乎所有Tensor操作，在Tensor被封装成Variable之后，可以调用它的.backward实现反向传播，自动计算所有梯度。
Variable包含的三个属性：
data：保存所包含的Tensor
grad：保存所对应的梯度，是个Variable类型
grad_fn：指向一个function对象，用来计算反向传播计算输入的梯度
梯度的求法即是对要求梯度的参数求偏导。必须设置requires_grad=True才能求梯度。

b=torch.randn(3,4,requires_grad=True)
y=x+b

在这里插入图片描述

#计算流程
x=torch.rand(1)
b=torch.rand(1,requires_grad=True)
w=torch.rand(1,requires_grad=True)
y=w*x
z=y+b
x.requires_grad,b.requires_grad,w.requires_grad,y.requires_grad
x.is_leaf,w.is_leaf,b.is_leaf,y.is_leaf,z.is_leaf
#反向传播计算
z.backward(retain_graph=True)#如果不清零会累加
w.grad
b.grad

在这里插入图片描述

#做一个线性回归，构造一组输入数据x和器对应的标签y
import torch
import numpy as np
x_value=[i for i in range(11)]
x_train=np.array(x_value,dtype=np.float32)
x_train=x_train.reshape(-1,1)
x_train.shape

import torch
import numpy as np
y_value=[2*i for i in x_value]
y_train=np.array(y_value,dtype=np.float32)
y_train=y_train.reshape(-1,1)
y_train.shape

线性回归模型
其实线性回归就是一个不加激活函数的全连接层
在这里插入图片描述
指定好参数和损失函数

整体代码

#线性回归模型
#其实线性回归就是一个不加激活函数的全连接层
import torch
import torch.nn as nn
class LinearRegressionModel(nn.Module):
    def __init__(self,input_dim,output_dim):
        super(LinearRegressionModel,self).__init__()
        self.linear=nn.Linear(input_dim,output_dim)
    def forward(self,x):
        out=self.linear(x)
        return out
input_dim=1
output_dim=1
model=LinearRegressionModel(input_dim,output_dim)
#如果用GPU跑
device=torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model.to(device)
#指定好参数和损失函数
epochs=1000
learning_rate=0.01
optimizer=torch.optim.SGD(model.parameters(),lr=learning_rate)
criterion=nn.MSELoss()
#训练模型
for epoch in range(epochs):
    epoch+=1
    #注意转换成tensor
    #CPU
    inputs=torch.from_numpy(x_train)
    labels=torch.from_numpy(y_train)
    #GPU
    inputs=torch.from_numpy(x_train).to(device)
    labels=torch.from_numpy(y_train).to(device)
    #梯度要清零每一次迭代
    optimizer.zero_grad()
    #向前传播
    outputs=model(inputs)
    #计算损失
    loss=criterion(outputs,labels)
    # 反向传播
    loss.backward()
    #更新权重参数
    optimizer.step()
    if epoch%50 ==0:
        print('epoch{},loss{}'.format(epoch,loss.item()))

输出结果（每隔50个输出一次）

epoch50,loss0.047476135194301605
epoch100,loss0.027078622952103615
epoch150,loss0.015444641932845116
epoch200,loss0.008809022605419159
epoch250,loss0.005024343729019165
epoch300,loss0.002865705406293273
epoch350,loss0.0016344860196113586
epoch400,loss0.0009322415571659803
epoch450,loss0.0005317159229889512
epoch500,loss0.0003032718668691814
epoch550,loss0.00017297608428634703
epoch600,loss9.865821630228311e-05
epoch650,loss5.6273445807164535e-05
epoch700,loss3.209552960470319e-05
epoch750,loss1.8306158381165005e-05
epoch800,loss1.0441513040859718e-05
epoch850,loss5.955844699201407e-06
epoch900,loss3.395614612600184e-06
epoch950,loss1.9374854218767723e-06
epoch1000,loss1.1051076853618724e-06

Tensor常见的形式
torch.Tensor(a,b) 分配了a*b矩阵，只分配空间，未初始化
torch.rand(a,b) 使用[0,1]均匀分布随机初始化二维数组
torch.Size() 查看其形状
对象相加的三种写法
y.add_(x) #这种加法会改变y的值
x+y #不会改变y的值
result=torch.Tensor(a,b) #预先分配空间
torch.add(x , y, out=result)#输入到result中

在这里插入图片描述

nn.Module是PyTorch提供的神经网络类，并在类中实现了网络各层的定义及前向计算与反向传播机制。在实际使用时，如果想要实现某个神经网络，只需继承nn.Module，在初始化中定义模型结构与参数，在函数forward()中编写网络前向过程即可。

1．nn.Parameter函数

2．forward()函数与反向传播

3．多个Module的嵌套

4．nn.Module与nn.functional库

5．nn.Sequential()模块

#这里用torch.nn实现一个MLP
from torch import nn

class MLP(nn.Module):
    def __init__(self, in_dim, hid_dim1, hid_dim2, out_dim):
        super(MLP, self).__init__()
        self.layer = nn.Sequential(
          nn.Linear(in_dim, hid_dim1),
          nn.ReLU(),
          nn.Linear(hid_dim1, hid_dim2),
          nn.ReLU(),
          nn.Linear(hid_dim2, out_dim),
          nn.ReLU()
       )
    def forward(self, x):
        x = self.layer(x)
        return x

用torch搭一个简易神经网络：
1、我们设置输入节点为1000，隐藏层的节点为100，输出层的节点为10
2、输入100个具有1000个特征的数据，经过隐藏层后变成100个具有10个分类结果的特征，然后将得到的结果后向传播

import torch
batch_n = 100#一个批次输入数据的数量
hidden_layer = 100
input_data = 1000#每个数据的特征为1000
output_data = 10

x = torch.randn(batch_n,input_data)
y = torch.randn(batch_n,output_data)

w1 = torch.randn(input_data,hidden_layer)
w2 = torch.randn(hidden_layer,output_data)

epoch_n = 20
lr = 1e-6

for epoch in range(epoch_n):
    h1=x.mm(w1)#(100,1000)*(1000,100)-->100*100
    print(h1.shape)
    h1=h1.clamp(min=0)
    y_pred = h1.mm(w2)
    
    loss = (y_pred-y).pow(2).sum()
    print("epoch:{},loss:{:.4f}".format(epoch,loss))
    
    grad_y_pred = 2*(y_pred-y)
    grad_w2 = h1.t().mm(grad_y_pred)
    
    grad_h = grad_y_pred.clone()
    grad_h = grad_h.mm(w2.t())
    grad_h.clamp_(min=0)#将小于0的值全部赋值为0，相当于sigmoid
    grad_w1 = x.t().mm(grad_h)
    
    w1 = w1 -lr*grad_w1
    w2 = w2 -lr*grad_w2

torch.Size([100, 100])
epoch:0,loss:112145.7578
torch.Size([100, 100])
epoch:1,loss:110014.8203
torch.Size([100, 100])
epoch:2,loss:107948.0156
torch.Size([100, 100])
epoch:3,loss:105938.6719
torch.Size([100, 100])
epoch:4,loss:103985.1406
torch.Size([100, 100])
epoch:5,loss:102084.9609
torch.Size([100, 100])
epoch:6,loss:100236.9844
torch.Size([100, 100])
epoch:7,loss:98443.3359
torch.Size([100, 100])
epoch:8,loss:96699.5938
torch.Size([100, 100])
epoch:9,loss:95002.5234
torch.Size([100, 100])
epoch:10,loss:93349.7969
torch.Size([100, 100])
epoch:11,loss:91739.8438
torch.Size([100, 100])
epoch:12,loss:90171.6875
torch.Size([100, 100])
epoch:13,loss:88643.1094
torch.Size([100, 100])
epoch:14,loss:87152.6406
torch.Size([100, 100])
epoch:15,loss:85699.4297
torch.Size([100, 100])
epoch:16,loss:84282.2500
torch.Size([100, 100])
epoch:17,loss:82899.9062
torch.Size([100, 100])
epoch:18,loss:81550.3984
torch.Size([100, 100])
epoch:19,loss:80231.1484

hub模块:
GitHub：https://github.com/pytorch/hub
模型：https://pytorch.org/hub/research-models