pytorch教程

文章目录

1 pytorch的安装
2 PyTorch基础知识
- 2.1 张量简介
- 2.2 初始化
- 2.3 张量的属性
- 2.4 ndarray与tensor互转
- 2.5 索引、切片、变形、聚合、矩阵拼接、切割、转置
3 pytorch自动微分
4 线性回归
5 分类
- 5.1 写法一
- 5.2 写法二

1 pytorch的安装

pytorch官网
https://pytorch.org/get-started/locally/
个人学习因此，选择CPU安装。
使用国内阿里云镜像安装

库名	作用
torchvision	图像视频处理
torchaudio	音频处理
torchtext	自然语言处理

pip install -i https://mirrors.aliyun.com/pypi/simple/ torch torchvision torchaudio torchtext

出现以下界面说明安装成功
验证是否安装成功

2 PyTorch基础知识

2.1 张量简介

分类：0维张量（标量）、1维张量（向量）、2维张量（矩阵）、3维张量（时间序列）、4维张量（图像）、5维张量（视频）
概念：一个数据容器，可以包含数据、字符串等
常见的构造Tensor的函数

函数	功能
Tensor(*sizes)	基础构造函数
tensor(data)	类似于np.array
ones(*sizes)	全1
zeros(*sizes)	全0
eye(*sizes)	对角为1，其余为0
arange(s,e,step)	从s到e，步长为step
linspace(s,e,steps)	从s到e，均匀分成step份
rand/randn(*sizes)	rand是[0,1)均匀分布；randn是服从N（0，1）的正态分布
normal(mean,std)	正态分布（均值为mean，标准差是std）
randperm(m)	随机排列

Tensor的运算

函数	作用
torch.abs(A)	绝对值
torch.add(A，B)	相加，A和B既可以是Tensor也可以是标量
torch.clamp(A，max，min)	裁剪，A中的数据若小于min或大于max，则变成min或max，即保证范围在[min，max]
torch.div(A，B)	相除，A%B，A和B既可以是Tensor也可以是标量
torch.mul(A，B)	点乘，A*B，A和B既可以是Tensor也可以是标量
torch.pow(A,n)	求幂，A的n次方
torch.mm(A,B.T)	矩阵叉乘，注意与torch.mul之间的区别
torch.mv(A,B)	矩阵与向量相乘，A是矩阵，B是向量，这里的B需不需要转置都是可以的
A.item()	将Tensor转化为基本数据类型，注意Tensor中只有一个元素的时候才可以使用，一般用于在Tensor中取出数值
A.numpy()	将Tensor转化为Numpy类型
A.size()	查看尺寸
A.shape	查看尺寸
A.dtype	查看数据类型
A.view()	重构张量尺寸，类似于Numpy中的reshape
A.transpose(0，1)	行列交换
A[1:]A[-1，-1]=100	切面，类似Numpy中的切面
A.zero_()	归零化
torch.stack((A，B)，sim=-1)	拼接，升维
torch.diag(A)	取A对角线元素形成一个一维向量
torch.diag_embed(A)	将一维向量放到对角线中，其余数值为0的Tensor

2.2 初始化

张量可以直接从数据中创建。数据类型是自动推断的

import torch

# 直接从数据创建张量
data = [[1, 2], [3, 4]]
x_data = torch.tensor(data)
print(f"Tensor from Data:\n {x_data} \n")

从 NumPy 数组创建

import numpy as np

# 从numpy创建张量
data = [[1, 2], [3, 4]]
np_array = np.array(data)
x_np = torch.from_numpy(np_array)
print(f"Tensor from Numpy:\n {x_np} \n")

根据另一个张量创建

import torch

# 根据另一个张量创建
data = [[1, 2], [3, 4]]
x_data = torch.tensor(data)

x_ones = torch.ones_like(x_data)  # 保留原有张量的形状和数据类型
print(f"Ones Tensor: \n {x_ones} \n")

x_rand = torch.rand_like(x_data, dtype=torch.float)  # 显式更改张量的数据类型

使用随机或恒定值创建.

import torch

shape = (2, 3,)  # 创建2行3列的张量
rand_tensor = torch.rand(shape)
ones_tensor = torch.ones(shape)
zeros_tensor = torch.zeros(shape)

print(f"Random Tensor: \n {rand_tensor} \n")
print(f"Ones Tensor: \n {ones_tensor} \n")
print(f"Zeros Tensor: \n {zeros_tensor}")

2.3 张量的属性

张量属性包括形状、数据类型和存储设备等

import torch

tensor = torch.rand(3,4)
print(f"Shape of tensor: {tensor.shape}")
print(f"Datatype of tensor: {tensor.dtype}")
print(f"Device tensor is stored on: {tensor.device}")

2.4 ndarray与tensor互转

import numpy as np
import torch

print(np.__version__)
print(torch.__version__)

print("tensor转ndarray")
a = torch.ones(5)
print(type(a))
b = a.numpy()
print(type(b))

print("ndarray转tensor")
a1 = np.ones(5)
print(type(a1))
b2 = torch.from_numpy(a1)
print(type(b2))

2.5 索引、切片、变形、聚合、矩阵拼接、切割、转置

import torch
import numpy as np

# 随机生成0-10的形状为4行5列的tensor
t = torch.randint(0, 10, (4, 5))
print(t)

# 查看形状
print(t.shape)

# 一 索引和切片
# 取第0行0列的数据
print(t[0, 0])

# 取第0行的数据
print(t[0])

# 取中间两行的数据
print(t[1:3])

# 取中间两列的数据
print(t[:, 1:3])

# 取中间两行和两列的数据
print(t[1:3, 1:3])

# 增加维度 变为 （4,5,1）
# 方法一
print(t.reshape(4, 5, 1))
# 方法二 None表示占个位置
print(t[:, :, None])
# 方法三 ...代表前面所有维度，None代表最后一个维度
print(t[..., None])
# 方法四 在中间插一个维度 （4,1,5）
print(t[:, None, :])

# 去除空白的维度
print(t.reshape(4, 5, 1).squeeze())
print(t[:, None, :].squeeze())

# 拉伸维度
print(t.unsqueeze(dim=0).shape)

tensor = torch.tensor([[1], [2], [3]])
print(tensor.expand(3, 4))

# 模拟卷积神经网络只取宽度和高度
# 32个通道，224宽，224高，3个卷积核（batch_size,W,H,C）
# numpy操作
n = np.random.random((32, 224, 224, 3))
print(n[0, :, :, 0].shape)
# torch操作
t = torch.tensor(n)
print(t.shape)
print(t[0, :, :, 0].shape)

# 二、变形 reshape和view
t = torch.randint(0, 10, (4, 5))
print(t)
# print(t.reshape(5,4))
# print(t.view(5,4))

# 三、聚合
# pytorch聚合的时候不指定维度和numpy表现是一样的，回把所有的维度聚合成一个数字
print(t.sum())
# dim(dimension)指定维度
# 行相加
print(t.sum(dim=0))
# 保持聚合掉的维度继续存在
print(t.sum(dim=0,keepdim=True))
# 列相加
print(t.sum(dim=1))
# 保持聚合掉的维度继续存在
print(t.sum(dim=1,keepdim=True))
# 聚合函数 max，min，mean，median，sum，argmin（最小值索引），argmax（最大值索引），std（标准偏差）
# 第一个维度最大值得索引（每列的最大值的索引）
print(t.argmax(dim=0))
# 第二个维度最大值得索引（每行的最大值的索引）
print(t.argmax(dim=1))

# 四、矩阵的拼接
t1 = torch.randint(0,10,size=(4,5))
t2 = torch.randint(0,10,size=(4,5))
print(t1)
print(t2)
# pytorch也有dot,但是，仅限于向量（一维）之间的运算。（numpy中不限于一维）
# 一维向量的点乘
# t1[0,0]*t2[0,0] + t1[0,1]*t2[0,1] + t1[0,2]*t2[0,2] + t1[0,3]*t2[0,3] + t1[0,4]*t2[0,4]
print(t1[0].dot(t2[0]))
# 默认也是按照dim=0，增加了行数
print(torch.concat((t1,t2)))
# 同样增加行数
print(torch.vstack((t1,t2)))
# 增加列
print(torch.concat((t1,t2),dim=1))
# 同样增加列数
print(torch.hstack((t1,t2)))

# 五、切割
print("--------------切割----------------")
t = torch.randint(0,10,size=(4,5))
print(t)
# 1+2+1=4,必须等于维度
print(t.split([1,2,1]))

# 六、转置
# 0维度和1维度互换
print(torch.permute(t,[1,0]).shape)
print(t.transpose(1,0).shape)

3 pytorch自动微分

自动微分其实就是求导

import torch

# requires_grad=True 表示对x求导
x = torch.ones(1, 1, requires_grad=True)

# 写一个计算公式，倒数是2
y = 2 * x + 2

# 反向传播求导
y.backward()

# 这里也是2
print(x.grad)

4 线性回归

from torch import nn, optim, tensor

# y = 2*x + 1
X = tensor([[1.0], [2.0], [3.0], [4.0]])
Y = tensor([[3.0], [5.0], [7.0], [9.0]])

# 训练模型（线性），可以获得预测结果。
model = nn.Linear(1, 1)

# 定义损失函数（均方误差损失（Mean Square Error Loss）），传入实际值和预测值，就可以获得损失函数。
# 这是常用于回归问题的损失函数
loss_fn = nn.MSELoss()

# 需要更新的参数-这里是一个生成器，可以节约内存
# model.parameters()

# 优化器（训练器） lr是学习率，可以梯度清零和更新参数。
optimizer = optim.SGD(model.parameters(), 0.001)

# 训练
for epoch in range(1000):
    for x, y in zip(X, Y):
        # 获得预测结果
        y_pred = model(x)
        # 获得损失函数，使用损失函数做反向传播
        loss = loss_fn(y, y_pred)
        # 梯度清零
        optimizer.zero_grad()
        # 反向传播
        loss.backward()
        # 更新参数
        optimizer.step()

# w的值
weight = model.weight
print(weight)
# b的值
bias = model.bias
print(bias)

5 分类

5.1 写法一

import torch
from torch import nn,float

# 1代表基数 2代表偶数
data = [[1, 3, 5, 7, 9, 1],
        [2, 4, 6, 8, 10, 0],
        [11, 13, 15, 17, 19, 1],
        [12, 14, 16, 18, 20, 0],
        [21, 23, 25, 27, 29, 1],
        [22, 24, 26, 28, 30, 0],
        [31, 33, 35, 37, 39, 1],
        [32, 34, 36, 38, 40, 0],
        [41, 43, 45, 47, 49, 1],
        [42, 44, 46, 48, 50, 0], ]
t_data = torch.tensor(data,dtype=float)

# 行都要，列不要最后一行
X = t_data[:, :-1]
print(type(X))
print(X)
# 行都要，列只要最后一样
Y = t_data[:, -1]
Y = Y.reshape(-1, 1)
print(type(X))
print(Y)

# 查看特征数，也就是有多少列
print(X.shape)

# 建一个两层的模型
model = nn.Sequential(
    # 输入是5个特征(X的列数)，输出50个神经元
    nn.Linear(5, 50),
    # 输如的神经元数就是上一层的输出50个，输出就是Y的列数
    nn.Linear(50, 1),
    # 激活函数(分类),将这个输出转化为一个在0和1之间的值。这个值可以看作是模型对输入数据的预测结果。
    nn.Sigmoid()
)

state_dict = model.state_dict()
print(state_dict)

# 二分类交叉熵(适用于二分类问题的一种损失函数)
loss_fn = nn.BCELoss()

# 优化器-梯度下降的优化算法,传入模型的参数为权重（w）和偏执（b）,学习率为0.001
optim_sgd = torch.optim.SGD(model.parameters(), 0.001)

# 正常神经网络是一批一批跑的
batch_size = 2
# 整除 根据批次大小计算步长，一共10行数据，每次跑两行，正好步长是5
steps = 10 // 2

# 开始训练
# 训练100次
for epoch in range(100):
    # 防止数据量过大,按照步长跑，把大数据切成一段一段的跑。
    for batch in range(steps):
        # 每一批的起始位置
        start = batch * batch_size
        end = start + batch_size
        x = X[start:end]
        y = Y[start:end]

        # 拿到预测结果
        y_pred = model(x)
        # 获取损失函数
        loss = loss_fn(y_pred, y)
        # 梯度清零
        optim_sgd.zero_grad()
        # 反向传播
        loss.backward()
        # 更新
        optim_sgd.step()

# 查看权重
print(model.state_dict())

# 计算准确率
# >=0.5 就是正样本
acc_rate = ((model(X).data.numpy() >= 0.5) == Y.numpy()).mean()

5.2 写法二

import torch
from torch import nn, float
import numpy as np

# 1代表基数 2代表偶数
data = [[1, 1],
        [2, 0],
        [11, 1],
        [12, 0],
        [21, 1],
        [22, 0],
        [31, 1],
        [32, 0],
        [41, 1],
        [42, 0], ]
t_data = torch.tensor(data, dtype=float)

# 行都要，列不要最后一行
X = t_data[:, :-1]

# 行都要，列只要最后一样
Y = t_data[:, -1]
Y = Y.reshape(-1, 1)

# 查看特征数，也就是有多少列
print(X.shape)


class DemoModl(nn.Module):
    def __init__(self):
        super().__init__()
        # 定义网络中会用到的东西
        # 输入是5个特征(X的列数)，输出50个神经元
        self.lin_1 = nn.Linear(1, 50)
        # 输如的神经元数就是上一层的输出50个，输出就是Y的列数
        self.lin_2 = nn.Linear(50, 1)
        # 激活函数(分类),将这个输出转化为一个在0和1之间的值。这个值可以看作是模型对输入数据的预测结果。
        self.sigmod = nn.Sigmoid()
        # 拐弯函数
        self.activate = nn.ReLU()

    def forward(self, input):
        # forward中写前向传播
        x = self.lin_1(input)
        x = self.activate(x)
        x = self.lin_2(x)
        x = self.sigmod(x)
        return x


# 学习率
lr = 0.001

# 获取模型函数
def get_model():
    model = DemoModl()
    # 返回模型和优化器
    return model, torch.optim.Adam(model.parameters(),lr=lr)

# 损失函数
loss_fn = nn.BCELoss()

# 获取模型和优化器
model,opt = get_model()
# 超参数初始化
batch_size = 2
steps = 10 // 2

# 训练100次
for epoch in range(1000):
    # 防止数据量过大,按照步长跑，把大数据切成一段一段的跑。
    for batch in range(steps):
        # 每一批的起始位置
        start = batch * batch_size
        end = start + batch_size
        x = X[start:end]
        y = Y[start:end]

        # 拿到预测结果
        y_pred = model(x)
        # 获取损失函数
        loss = loss_fn(y_pred, y)
        # 梯度清零
        opt.zero_grad()
        # 反向传播
        loss.backward()
        # 更新
        opt.step()

print('loss=========',loss_fn(model(X),Y))

acc_rate = ((model(X).data.numpy() >= 0.5) == Y.numpy()).mean()
print(acc_rate)

print(np.unique(model(X).data.numpy()))