深度学习与 PyTorch 基础

笔记

1 深度学习简介

1.1 深度学习概念

深度学习是机器学习的一类算法, 以人工神经网络为结构, 可以实现自动提取特征
深度学习核心思想是人工神经网络为结构, 自动提取特征

1.2 深度学习特点

自动提取特征
解释性差
大量数据和高性能计算能力
非线性转换(引入非线性因素)

1.3 深度学习模型

ANN 人工神经网络感知机
CNN 卷积神经网络图像/视频
RNN 循环神经网络 NLP
transformer RNN衍生出来的
自编学习器
...

1.4 深度学习应用场景

自然语言处理NLP
- 生成式AI AIGC 大模型
- 机器翻译
- 语音识别
- ...
计算机视觉CV
- 图像识别
- 面部解锁
- 视频合成
- ...
推荐系统
- 电影
- 音乐
- 文章
- 视频
- 商品

2 PyTorch框架简介

pytorch是深度学习的框架, python的第三方包, 数据是以张量类型存在
pytorch特点
- 数据类型是张量类型
- 自动微分模块, 自动求导/梯度
- 可以在GPU/TPU/NPU上运行, 加速运行
- 兼容各种平台系统/硬件(显卡)
pytorch目前更新到2.5版本

3 张量创建

3.1 什么是张量

张量是矩阵, 可以是多维
- 0维->标量
- 1维->[1 2 3 4 5]
- 2维->[[1 2 3],[4 5 6]]
- 3维...
张量是通过类创建出来的对象, 提供各种方法和属性

3.2 基本创建方式

torch.tensor(data=): 指定数据
torch.Tensor(data=, size=): 指定数据或形状

torch.IntTensor(data=)/FloatTensor(): 指定数据

import torch
import numpy as np


# torch.tensor(data=, dtype=,): 根据指定数据或指定元素类型创建张量
# data: 数据
# dtype: 元素类型
def dm01():list1 = [[1., 2, 3], [4, 5, 6]]  # 创建的张量为float32int1 = 10# array默认类型是float64, 所以创建的张量为float64n1 = np.array([[1., 2., 3.], [4., 5., 6.]])t1 = torch.tensor(data=list1)t2 = torch.tensor(data=int1)t3 = torch.tensor(data=n1)print('t1的值->', t1)print('t1类型->', type(t1))print('t1元素类型->', t1.dtype)print('t2的值->', t2)print('t2类型->', type(t2))print('t3的值->', t3)print('t3类型->', type(t3))


# torch.Tensor(data=, size=): 根据指定数据或指定形状创建张量
# data: 数据
# size: 形状, 接收元组 (0轴, 1轴, ...) -> 元组有多少个元素就是多少维张量, 对应维度上值就是数据个数
def dm02():# 指定数据t1 = torch.Tensor(data=[[1.1, 1.2, 1.3], [2.2, 2.3, 2.4]])print('t1的值->', t1)print('t1类型->', type(t1))# 指定形状t2 = torch.Tensor(size=(2, 3))print('t2的值->', t2)print('t2类型->', type(t2))


# torch.IntTensor(data=)/LongTensor()/FloatTensor()/DoubleTensor(): 创建指定类型的张量
# data: 数据
def dm03():# 如果元素类型不是指定类型, 会自动转换t1 = torch.IntTensor([[1.1, 2, 3.7], [4, 5, 6]])t2 = torch.FloatTensor([[1.1, 2, 3.7], [4, 5, 6]])print('t1的值->', t1)print('t1类型->', type(t1))print('t1元素类型->', t1.dtype)print('t2的值->', t2)print('t2类型->', type(t2))print('t2元素类型->', t2.dtype)


if __name__ == '__main__':dm01()# dm02()# dm03()

3.3 线性和随机张量

线性张量
- torch.arange()
- torch.linspace()

随机张量

torch.rand()/randn()
torch.randint()
torch.initial_seed()
torch.manual_seed()

import torch


# torch.arange(start=, end=, step=): 创建指定步长的线性张量  左闭右开
# start: 起始值
# end: 结束值
# step: 步长, 默认1
# torch.linspace(start=, end=, steps=): 创建指定元素个数的线性张量  左闭右闭
# start: 起始值
# end: 结束值
# steps: 元素个数
# step=(end-start)/(steps-1)  value_i=start+step*i
def dm01():t1 = torch.arange(start=0, end=10, step=2)print('t1的值是->', t1)print('t1类型是->', type(t1))t2 = torch.linspace(start=0, end=9, steps=9)print('t2的值是->', t2)print('t2类型是->', type(t2))


# torch.rand(size=)/randn(size=): 创建指定形状的随机浮点类型张量
# torch.randint(low=, high=, size=): 创建指定形状指定范围随机整数类型张量  左闭右开
# low: 最小值
# high: 最大值
# size: 形状, 元组

# torch.initial_seed(): 查看随机种子数
# torch.manual_seed(seed=): 设置随机种子数
def dm02():# (5, 4): 5行4列t1 = torch.rand(size=(5, 4))print('t1的值是->', t1)print('t1类型->', type(t1))print('t1元素类型->', t1.dtype)print('t1随机种子数->', torch.initial_seed())# 设置随机种子数torch.manual_seed(seed=66)t2 = torch.randint(low=0, high=10, size=(2, 3))print('t2的值是->', t2)print('t2类型->', type(t2))print('t2元素类型->', t2.dtype)print('t2随机种子数->', torch.initial_seed())



if __name__ == '__main__':# dm01()dm02()

3.4 0/1/指定值张量

torch.ones/zeros/full(size=[, fill_value=])

torch.ones_like/zeros_like/full_like(input=tensor[, fill_value=])

import torch


# torch.ones(size=): 根据形状创建全1张量
# torch.ones_like(input=): 根据指定张量的形状创建全1张量
def dm01():t1 = torch.ones(size=(2, 3))print('t1的值是->', t1)print('t1的形状是->', t1.shape)print('t1的元素类型是->', t1.dtype)# 形状: (5, )t2 = torch.tensor(data=[1, 2, 3, 4, 5])t3 = torch.ones_like(input=t2)print('t2的形状是->', t2.shape)print('t3的值是->', t3)print('t3的形状是->', t3.shape)


# torch.zeros(size=): 根据形状创建全0张量
# torch.zeros_like(input=): 根据指定张量的形状创建全0张量
def dm02():t1 = torch.zeros(size=(2, 3))print('t1的值是->', t1)print('t1的形状是->', t1.shape)print('t1的元素类型是->', t1.dtype)# 形状: (5, )t2 = torch.tensor(data=[1, 2, 3, 4, 5])t3 = torch.zeros_like(input=t2)print('t2的形状是->', t2.shape)print('t3的值是->', t3)print('t3的形状是->', t3.shape)


# torch.full(size=, fill_value=): 根据形状和指定值创建指定值的张量
# torch.full_like(input=, fill_value=): 根据指定张量形状和指定值创建指定值的张量
def dm03():t1 = torch.full(size=(2, 3, 4), fill_value=10)t2 = torch.tensor(data=[[1, 2], [3, 4]])t3 = torch.full_like(input=t2, fill_value=100)print('t1的值是->', t1)print('t1的形状是->', t1.shape)print('t3的值是->', t3)print('t3的形状是->', t3.shape)


if __name__ == '__main__':# dm01()# dm02()dm03()

3.5 指定元素类型张量

tensor.type(dtype=)

tensor.half()/float()/double()/short()/int()/long()

import torch


# torch.tensor(data=, dtype=):
# dtype: 指定元素类型, 浮点类型默认是float32

# tensor.type(dtype=): 修改张量元素类型
# torch.float32
# torch.FloatTensor
# torch.cuda.FloatTensor
def dm01():t1 = torch.tensor(data=[[1., 2., 3.], [4., 5., 6.]], dtype=torch.float16)print('t1的元素类型->', t1.dtype)# 转换成float32t2 = t1.type(dtype=torch.FloatTensor)t3 = t1.type(dtype=torch.int64)print('t2的元素类型->', t2.dtype)print('t3的元素类型->', t3.dtype)


# tensor.half()/float()/double()/short()/int()/long()
def dm02():t1 = torch.tensor(data=[1, 2])print('t1的元素类型->', t1.dtype)# t2 = t1.half()t2 = t1.int()print(t2)print('t2的元素类型->', t2.dtype)


if __name__ == '__main__':# dm01()dm02()

4 张量类型转换

4.1 张量转换为NumPy数组

import torch
import numpy as np


# 张量转换成numpy数组
# tensor.numpy(): 共享内存, 修改一个另外一个也跟着变, 可以通过copy()函数不共享内存
def dm01():t1 = torch.tensor([[1, 2, 3], [4, 5, 6]])print('t1->', t1)# 转换成numpy数组# n1 = t1.numpy()n1 = t1.numpy().copy()print('n1->', n1)print('n1的类型->', type(n1))# 修改n1的第一个值# [0][0]->第一行第一列的元素n1[0][0] = 100print('n1修改后->', n1)print('t1->', t1)

4.2 NumPy数组转换为张量

# numpy数组转换成张量
# torch.from_numpy(ndarray): 共享内存, 对ndarray数组进行copy()
# torch.tensor(data=ndarray): 不共享内存
def dm02():n1 = np.array([[1, 2, 3], [4, 5, 6]])# 转换成张量# 共享内存t1 = torch.from_numpy(n1)# 不共享内存# t1 = torch.from_numpy(n1.copy())# t1 = torch.tensor(data=n1)print('t1->', t1)print('t1类型->', type(t1))# 修改张量元素t1[0][0] = 8888print('t1修改后->', t1)print('n1->', n1)

4.3 提取标量张量的数值

import torch


# tensor.item(): 提取单个元素张量的数值, 张量可以是标量张量/一维张量/二维张量...只要是单个元素即可
def dm01():# 数值转换成张量# 标量t1 = torch.tensor(data=10)# 一维# t1 = torch.tensor(data=[10])# 二维# t1 = torch.tensor(data=[[10]])print('t1->', t1)print('t1形状->', t1.shape)# 单个元素张量转换成数值, 提取数值print('t1.item()->', t1.item())


if __name__ == '__main__':dm01()

5 张量数值计算

5.1 基本运算

+ - * / -
tensor/torch.add() sub() mul() div() neg()

tensor/torch.add_() sub_() mul_() div_() neg_()

import torch


# 运算: 张量和数值之间运算, 张量和张量之间运算
# + - * / -
# add(other=) sub() mul() div() neg()  不修改原张量
# add_() sub_() mul_() div_() neg_()  修改原张量

def dm01():# 创建张量t1 = torch.tensor(data=[1, 2, 3, 4])# 张量和数值运算t2 = t1 + 10print('t2->', t2)# 张量之间运算, 对应位置的元素进行计算t3 = t1 + t2print('t3->', t3)
# add() 不修改原张量t1.add(other=100)t4 = torch.add(input=t1, other=100)print('t4->', t4)
# neg_() 修改原张量, 负号t5 = t1.neg_()print('t1->', t1)print('t5->', t5)


if __name__ == '__main__':dm01()

5.2 点乘运算

对应位置的元素进行乘法计算, 一般要求张量形状相同

import torch


# 点乘: 又称为阿达玛积, 张量元素级乘法, 对应位置的元素进行点乘, 一般要求两个张量形状相同  *  mul()
def dm01():# t1 = torch.tensor(data=[[1, 2], [3, 4]])# (2, )t1 = torch.tensor(data=[1, 2])# (2, 2)t2 = torch.tensor(data=[[5, 6], [7, 8]])t3 = t1 * t2print('t3->', t3)t4 = torch.mul(input=t1, other=t2)print('t4->', t4)


if __name__ == '__main__':dm01()

5.3 矩阵乘法运算

第一个矩阵的行数据和第二个矩阵的列数据相乘

import torch


# 矩阵乘法: (n, m) * (m, p) = (n, p)  第一个矩阵的行和第二个矩阵的列相乘  @  torch.matmul(input=, ohter=)
def dm01():# (2, 2)t1 = torch.tensor(data=[[1, 2],[3, 4]])# (2, 3)t2 = torch.tensor(data=[[5, 6, 7],[8, 9, 10]])
# @t3 = t1 @ t2print('t3->', t3)# torch.matmul(): 不同形状, 只要后边维度符合矩阵乘法规则即可t4 = torch.matmul(input=t1, other=t2)print('t4->', t4)


if __name__ == '__main__':dm01()

6 张量运算函数

mean()
sum()
min()/max()
dim: 按不同维度计算
exp(): 指数
sqrt(): 平方根
pow(): 幂次方

log()/log2()/log10(): 对数

import torch


def dm01():# 创建张量t1 = torch.tensor(data=[[1., 2, 3, 4],[5, 6, 7, 8]])
# dim=0 按列# dim=1 按行# 平均值print('所有值平均值->', t1.mean())print('按列平均值->', t1.mean(dim=0))print('按行平均值->', t1.mean(dim=1))# 求和print('所有值求和->', t1.sum())print('按列求和->', t1.sum(dim=0))print('按行求和->', t1.sum(dim=1))# sqrt: 开方 平方根print('所有值开方->', t1.sqrt())# pow: 幂次方  x^n# exponent:几次方print('幂次方->',torch.pow(input=t1, exponent=2))# exp: 指数 e^x  张量的元素值就是xprint('指数->', torch.exp(input=t1))# log: 对数  log(x)->以e为底  log2()  log10()print('以e为底对数->', torch.log(input=t1))print('以2为底对数->', t1.log2())print('以10为底对数->', t1.log10())


if __name__ == '__main__':dm01()