5、Pytorch基础语法-乱七八糟的网页和视频笔记

是前面1234的重新复习，还是一些基础语法知识

主要参考：

PyTorch 源码解读之 nn.Module：核心网络模块接口详解 - 知乎

一、张量Tensor

各种数据类型都被成为张量，阶指的是高维数组中数的个数，即形状

传入列表 数组 都可以转为tensor

1、tensor的创建：

import torch
import numpy as np
t1=torch.Tensor([1,2,3])
#将array类型转换为torch类型
array1=np.arange(12).reshape(3,4)
array1
torch.Tensor(array1)
#用torch的api创建tensor
torch.empty(3,4)#空数组（里面有随机垃圾数据填充）
torch.zeros(3,4)
torch.ones(3,4)
torch.rand(3,4)#三行四列01区间的浮点型tensor
torch.randint(3,10,(2,2))#创建3-10区间的，形状为两行两列的tensor
#或者写详细一些torch.randint(low=3,high=10,size=(2,2))
torch.randn(3,4)#创建均值为0方差为1的自然分布

**关于array与arange

#一个参数 默认起点0，步长为1 输出：[0 1 2]
a = np.arange(3)
#两个参数 默认步长为1 输出[3 4 5 6 7 8]
a = np.arange(3,9)
#三个参数 起点为0，终点为3，步长为0.1 输出[ 0. 0.1  0.2  0.3 ... 2.9]
a = np.arange(0, 3, 0.1)

2、tensor的常见 *** 作

*获取与转置（切片略

a=torch.tensor(np.arange(1))
a.item()#item可以把tensor里面仅有的一个数取出
a.size()#size可以输出tensor的大小
a.dim()#获取阶数
a.numpy()#转化为numpy类型
a=torch.tensor(np.arange(3,9))
b=a.view(2,3)#-1表示根据另一个维度自动匹配
#转置 *** 作(假设b为三维)
b.transpose(0,1)#交换0，1维度
b.permute(1,0,2)#和上面一样，交换01维度

*数据类型

x.dtype()#获取数据类型
torch.ones([2,3],dtype=torch.float32)#创建的时候指定数据类型
x.double()#直接修改数据类型

 3、tensor常见的加法

x=torch.rand(5,3)
x=x.new_ones(5,3,dtype=torch.float)#覆盖一个已经有的torch并创建一个全一向量
y=torch.rand(5,3)
x+y
x.add_(y)#就地修改，直接覆盖x的值为x+y

4、调用GPU进行 *** 作

torch.cuda.is_available()
#返回true即当前的GPU支持计算cuda
device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
device#输出此时的是GPU/CPU
a=torch.zeros([2,3],device=device)#使用cuda进行计算
device=torch.device("cpu")#重新设置在CPU上运行
a.to(device)#将刚刚运行的结果a也转化为CPU的

二、pytorch写简单模型

#梯度下降与反向传播
#后续需要这个tensor来计算梯度：则在初始化参数的时候将requires_grad记录为true，并记录 *** 作
x=torch.ones(2,2,requires_grad=True)
print(x.requires_grad)
x.requires_grad_(False)#如果忘记修改了，可以后期原地修改
print(x.requires_grad)
b=(x*x).sum()#平方求和
#如果不想要有梯度记录，可以如下：
with torch.no_grad():
  c=(x*x).sum()
print(c.requires_grad)#这时就是False

反向传播：output.backward()
获取梯度（会累加）：x.grad()

所以注意每次计算梯度的时候都要将梯度置为0

要获得requires_grad=True的数据，需要用x.data()来获取里面的值，不能直接输出x，这样会记录到梯度里面

相同的，想将tensor数据转为numpy数据的时候也需要重新 *** 作，代码：x.detach().numpy()

1、简单线性回归

import matplotlib.pyplot as plt
import numpy
#准备数据y=3x+0.8
x=torch.rand([500,1])#0-1数据，n行1列
y_true=x*3+0.8
learning_rate=0.01

#计算y_predict
w=torch.rand([1,1],requires_grad=True)#x*w保证还是n行1列
b=torch.tensor(0,requires_grad=True,dtype=float)#只有浮点型tensor才可以设置

#通过循环反向传播，更新参数
for i in range(500):
  #计算loss
  y_predict=torch.matmul(x,w)+b#numpy.matmul函数返回两个数组的矩阵乘积
  loss=(y_true-y_predict).pow(2).mean()#pow函数表示几次方

  if w.grad is not None:
    w.grad.data.zero_()
  if b.grad is not None:
    b.grad.data.zero_()
  loss.backward()

  w.data=w.data-learning_rate*w.grad#迭代更新
  b.data=b.data-learning_rate*b.grad
  print(w.item(),b,loss.item())
#画图更直观展示
plt.figure(figsize=(20,8))
plt.scatter(x.numpy().reshape(-1),y_true.numpy().reshape(-1))
y_predict=torch.matmul(x,w)+b
plt.plot(x.numpy().reshape(-1),y_predict.detach().numpy().reshape(-1),c="r")#颜色是红色
plt.show()

三、pytorch常用模型

1、nn.Module

是torch.nn提供的Module类，后续只要继承与它就可以

写在第二篇