深度学习pytorch

分类与回归

一：构成元素

样本，模型，训练，测试（评价），推理

• 1.回归：连续值问题
• 2.样本：属性（x）+标签（y）,y=f（x）， 对样本建模
• 3.模型(fx),f(x)=w+b
• 4.训练：即求解w，b
• 5.推理：由属性 推理出标签
• 总结：标签（y）（数字化）=w*样本（x）+b，w和b（tensor表示）

二：pytorch概念

1. 标量：一个数字。o维张量（点）
2. 向量：一维表格,[1,2,3]（长）
3. 矩阵：二维（面）
4. 张量：描述任意维度，H*W*C（长方体）

三：tensor（张量）操作

1.基本操作

import torch

# 张量
a=torch.Tensor[[1,2],[3,4]]    
print(a,type())      #显示torch.tensor

# 全为1
# 1位的浮点数
a=torch.ones(2,2)     # zeros
print(a)       # 全为1（两行两列）

# 单位矩阵（对角1，其余0）
a=torch.eye(2,3)
print(a)      # 两行三列单位矩阵

# zeros_like
# 创建相同形状的按"要求"的张量（传入张量）
a=torch.Tensor(2,3)

# 等间隔数
a=torch.linspace(2,10,4)
print(a)      # 2-10,取等间隔的4个数

# 随机数（数值在0-1）
torch.rand(2,3)  # 两行三列
# 正常化
a=torch.rand(2,3)*10

2.分配设备

dev=torch.device("cpu")
dev_gpu=torch.device("cuda:0")   # 加冒号

a=torch.tensor([2],device=dev)
print(a)

# 两个属性
a=torch.tensor([2],dtype=torch.float32,device=dev)

3.稀疏张量

信息简洁（都是有用信息）

a=torch.tensor([[0,1,2],[0,1,2]])     # 行，列位置
b=torch.tensor([1,2,3])             # 数值
c=torch.sparse_coo_tensor(a,b,(4,4))   # 稀疏矩阵（只显示非0）（节省空间）
print(c)    

e=c.to_dense()   # 普通矩阵（0位置也显示）
print(e)

也可以定义两个属性：dtype,device

4.算术运算

基础运算示例：加

1. a+b
2. c=torch.add(a，b)
3. a.add(b) # 需要用变量承接
4. a.add_(b) # 直接将结果赋值给a(原地操作)

减sub，乘(点乘，哈达玛积，对应数相乘)mul，除(/)div

幂

torch.pow(a,2)
a.pow(2)
a**2
a.pow_(2)

开方

a.sqrt()

a.sqrt_()

对数

torch.log(a)
torch.log_(a)
torch.log10(a)

5.矩阵运算

二维（mxn,nxp，结果：mxp）

torch.mm()
torch.matmul()  # 常用

高维(只作用在最后两个维度<行列>，前面维度须保持一致<大块，小块>)

a.matmul(b)

torch.matmul(a,b)

四：广播机制

功能：将张量扩展为相同大小

条件：右对齐（最右维度数相同；两个张量中最右维度至少有1个1）

a=torch.rand(2,3)
b=torch.rand(3)

c=a+b  # 广播机制

五：数据处理

取余、整

torch.floor(a)   # 向下取整
.ceil(a)   # 向上取整

.round(a)   # 四舍五入

.trunc(a)  # 整数部分
.frac(a)    # 小数部分

a%2   # 对2取余

大小比较，排序，取数，无穷和空判断

都返回矩阵<True,False>

# 1.比较
torch.eq(a,b)
.ge     # 大于等于
.gt     # 大于
.le     # 小于等于
.lt     # 小于
.ne     # 不等

.equal(a,b)  # 元素及大小


# 2.排序
# 升序
torch.sort(a)   # 返回排序后的张量 及其 原位置索引张量

# 降序
torch.sort(a,dim=1,descending=True)   #  dim某一维度，descending降序


# 3，取值
# k取前k个值，largest取最大的数，sorted降序
torch.topk(a,k=2,dim=1,larget=True,sorted=True)

# k取第k个数
torch.kthvalue(a,k=3,dim=0)


# 4.判断
torch.isinf(a/0)  # 无穷大
.isnan(a)  # 空值

六：函数

三角函数：

常用：torch.cos() # 相似，角度问题

统计学函数:

torch.std()     # 标准差
.var()     # 方差
.bincount()    # 每个值的频数
.histc()   # 直方图

其他函数:

torch.abs() 绝对值函数(l1 loss)，近似二次函数（l2 loss）

torch.sign() 符号函数，类似分段函数（-1，0，1），适于分类问题，结果离散化

torch.sigmoid() 分类问题，可求导，用于激活函数，大量数分布在0，1线附近

分布函数:

torch.distributions()

七：随机抽样

torch.manual_seed(1)     # 随机种子（保证随机抽样结果一致）
torch.normal(a,b)   # 随机数满足的分布

八：范数

度量某个向量空间（矩阵）中每个向量的长度或大小（模）

作用：定义loss，参数约束

• 1范数：l1 loss
• 2范数：l2 loss
• p范数:torch.dist(a,b,p=2) # p=2欧拉距离，p=1曼哈顿距离（两个张量形状相同）（算两个张量之间的距离，向量相似度，RAG检索，特征距离衡量）
• 核范数：torch.norm(a,p='fro')

九：矩阵分解

特征值分解（EVD）

应用算法：PCA（提取主要成分，n维特征映射到k维上）

矩阵（方阵）分解为：特征值+特征向量

Av=λv --> A=Q∑(Q*-1）(倒数)

(v特征向量，λ特征值；Anxn方阵，Q及其倒数特征向量，∑特征值组成的对角矩阵)

奇异值分解（SVD）

应用算法：LDA

A=u∑（V*T）(转置) # 维度：mxn =mxm，mxn，nxn

∑特征值（对角矩阵）

torch.svd()

十：tensor的裁剪

作用：1.tensor中元素范围过滤与稳定，防止过拟合（正则化）。2.进行loss计算时，防止梯度离散（无穷小）与梯度爆炸（无穷大）。3.定点与量化

# 值约束：
a.clamp(2,5)   # 数值约束在2-5

十一：索引与数据筛选

torch.where（条件,a,b）  # 按条件从x,y中选出满足的元素组成新tensor   
torch.gather（）   # 指定维度上按索引输出
torch.index_select()   # 按照指定索引输出
torch.masked_select()    # 按照mask输出，输出为向量
torch.take()    # 输入看成1维，按索引输出
torch.nonzero()    # 输出非0元素坐标

十二：拼接

torch.cat()  # 按照已经存在的维度进行拼接
torch.stack()  # 按照新维度进行拼接
torch.gather() 在指定维度上按照索引赋值输出

十三：张量切片，变形，填充

切片:

torch.chunk() # 按照某个维度平均分块
torch.split()  # 按照某个维度依照第二个参数给出的list/int进行分割

变形:

torch.squeeze()   # 去除维度大小为1的维度
torch.unbind()  # 去除某个维度
torch.unsqueeze()  # 指定位置添加维度

torch.flip()  # 按照给定维度翻转张量

填充：

torch.full((2,,3),3.14)   # 定义tensor并填充指定的数

十四：频谱操作

作用：用 FFT/STFT/DCT把张量数据从空域 / 时域 变换到频域，并在频域做滤波、增强、分析，再变回来

傅里叶变换

torch.fft()
torch.ifft()
torch.rfft()
torch.irfft()
torch.stft()

十五：cpu与线程

1.并行化

torch.get_num_threads() # 获得用于并行化cpu操作的openMP线程数

torch.set_num_threads() # 设定用于并行化cpu操作的openMP线程数

2.分布式（若有多个cpu）

3.tensor与numpy转换

a=np.zeros([2,2])
out=torch.from_numpy(a)

# numpy转tensor

十六：autograd

自动计算梯度

1、

导数：变化率，切线的斜率，瞬时速度

方向导数：无数个切线的斜率的定义（每个切线代表一个方向）

偏导数：多元函数降维时的变化（定y变x）

梯度：无数个切线中变化最快的那个

注意：一元函数一个点只有一个切线，多元函数切线不止一个

2、

计算梯度

链式法则：

y=2x,z=y*y

则dz/dx=dz/dy*dy/dx

3、

grad(属性）：存反向传播后算出来的导数（梯度）

grad_fn：指示梯度函数类型，记录运算类型（结果节点有效）（搭建计算图，自动求导）

4、

torch.autograd.backward()

torch.autograd.grad()

torch.autograd.Function

十七：torch.nn库

神经网络模块化接口

1、nn.parameter # 定义可训练参数

self.Params=nn.parameterList([nn.parameter(torch.randn(10,10))]

2、网络层定义

nn.Linear、nn.conv2d、nn.ReLU、nn.MaxPool、nn.MSELoss

3、nn.functional # 所有函数

torch.nn.functional.conv2d()

4、nn.ModelList

nn.ModelDict

nn.Sequential

5、保存中间模型

state_dict()

load_state_dict

6、反向传播

需要更新：self.register_Parameter()

不需更新：self.register_buffer()

十八：工具

1、visdom

支持numpy,pytorch,Tensor

python -m visdom.server 启动

import visdom
vis.text()
vis.image()

2、tensorboardX

安装：pip3 install tensorboardX

导入：From tensorboardX import SummaryWrite

3、torchvision

vision.datasets 视觉数据集

vision.models 训练好的模型

vision.transforms 图像操作

十九：机器学习与神经网络

关系：人工智能--机器学习--深度学习--神经网络（图的关系）

神经元-神经元 线性运算 y=wx+b

drop 正则化（参数多时）

感知器（单元结构）

前向传播：计算输出值的过程（参数已知）

反向传播BP：输出结果与真实值间的偏差，逐层调节参数。（更新参数：导数与学习率）

偏差：精确度

方差：稳定度（每一次输出与期望结果）

范数：weight_decay

Dropout：nn.Dropout(p=0.5)

防止过拟合：补充数据集；减少参数；Dropout；Earlystopping；正则化，稀疏化。

防欠拟合：加大参数；减少正则参数；充分训练。

二十：实战

过程：

1. 解析数据
2. 搭建网络
3. 定义损失函数
4. 定义优化器
5. 训练模型，获取参数
6. 测试样本test

房价预测模型

import torch
import numpy as np

ff=open("housing.data").readlines()
data=[]
for item in ff:
   out=re.sub(r"\s{2,}"," ",item).strip()
   print(out) 
   data.append(out.split(" "))

手写数字分类

import torch
import torchvision.datasets as dataset

神经网络

一：计算机视觉

基本概念

图像处理

特征工程

二：卷积层

1、卷积层：图像与滤波矩阵（卷积核）做内积操作

nn.Conv2d()

常见卷积操作：

1. 分组卷积

• 空洞卷积
• 深度可分离卷积（分组卷积+1x1卷积）
• 反卷积
• 可变形卷积

2、感受野：特征图上一个点，能 "看见" 原图多大范围，就是感受野。

层数越深，感受野越大

做目标检测、分割 必须关心感受野：感受野太小，看不到完整物体，识别不准

假设卷积核大小 k，步幅 s下一层感受野：RFnew​=RFold​+(k−1)×s

3、压缩卷积层参数和计算量（感受野不变）

• 采用多个3x3卷积核代替大卷积核
• 采用深度可分离卷积
• 通道shuffle
• Pooling层
• Stride=2

三：池化层

1、池化层：压缩特征图尺寸、降维、简化信息（变小、降维、丢细节），不训练参数，只做聚合（跟在卷积层后）

1. 使特征图变小，简化网络计算复杂度
2. 进行特征压缩，提取主要特征

方法：Max Pooling（最大池化），Average Pooling（平均池化）

nn.MaxPool2d()

2、上采样层：把特征图尺寸变大（和池化层反过来）

方法：最近邻插值；双线性插值 ；反卷积 / 转置卷积

nn.functional.interpolate()

torch.nn.ConvTranspose2d()

四：激活层

激活函数：给网络引入非线性 ，让模型能学**复杂特征，**不改变尺寸、形状、无参数

ReLU 层、Sigmoid 层、Tanh 层，都属于激活层。

位置固定：卷积层 / 全连接层 后面必跟激活层（ 卷积→激活→池化**）**

torch.nn.RELU()

五：BN层（BatchNorm层）

批量归一化

原因：网络一层层往下走，数据分布会慢慢跑偏（均值变大、方差乱跳），BN 强行把数据 "扶正"，不让分布乱飘，后面网络好学习、训练更稳。

作用：给每层数据做标准化，稳住分布、加速训练、稳梯度、少过拟合

位置：卷积层 → BN 层 → 激活层 → 池化层

效果：

1. 把每层的输入数据拉回到：均值接近 0，方差接近 1
2. 加速训练、收敛更快
3. 缓解梯度消失 / 爆炸
4. 有轻微正则化效果，减少过拟合

学习率可以设大一点，收敛快

nn.BatchNorm2d()

六：全连接层（FC层）

前一层每个神经元 和 后一层每个神经元 全部互相连接

作用：把前面卷积、池化、BN 提取好的所有特征揉在一起 ，最后用来分类、回归。

位置：卷积→BN→激活→池化 → Flatten 展平 → 全连接层 → 输出分类

• 把二维特征图 展平（Flatten） 成一维向量
• 通过矩阵运算做特征融合、变换
• 最后一层全连接输出：类别分数

nn.Linear()

缺点：参数巨多，容易过拟合

注意： 用1x1卷积 +全局平均池化代替全连接，减少参数量

七：损失层

损失函数：计算损失值（预测值与真实标签做对比，得出误差分数Loss）

1. Loss小,模型预测准
2. loss.backward() 求梯度，更新模型参数，让模型慢慢变聪明**（反向传播）**

位置：数据 → 卷积 → BN → 激活 → 池化 → 全连接 → 损失层 → 算 Loss → 反向传播更新参数

只在训练阶段用

**nn.CrossEntropyLoss() **交叉熵损失(分类)

**nn.MSELoss() **均方误差（回归）

nn .BCELoss 二分类损失（二分类）

八：经典卷积神经网络

轻量型：MobileNet V1-V3、ShuffleNet、squeezeNet

简单：LeNet、AlexNet、VGGNet （串联）

复杂：ResNet（跳连）、InceptionNet V1-V4（并行）、DenseNet

1、MobileNetV1（2017，Google）

创新：深度可分离卷积（Depthwise Separable Conv）

网络结构（28 层，输入 224×224×3）：

1. 第 1 层：标准 3×3 卷积（降采样）
2. 第 2~27 层：13 组深度可分离卷积（每组 2 层：DW+PW），逐步降采样、升通道
3. 第 28 层：全局平均池化 → 全连接 → Softmax 分类

两个超参数：

• 宽度乘数 α（0~1）

  • 作用：缩小每层通道数（如 α=0.5，通道减半）
  • 效果：α 越小，模型越小、越快、精度略降

• 分辨率乘数 ρ（0~1）

  • 作用：缩小输入图像尺寸（如 ρ=0.5，224→112）
  • 效果：ρ 越小，计算量越少、速度越快

九：Attention（注意力机制）

给每个特征 分配不同**权重，重要的权重高，**重点关注关键信息，忽略无关信息

三要素：QKV（查询，键，值）

• Q 和 K 做相似度计算 → 算出注意力分数
• 分数过 Softmax → 变成权重分布
• 权重和 V 加权求和 → 输出加权后的特征

经典：ResNet+Attention、SENet/Channel Attention

十：学习率（lr）

每一次参数更新的步子大小

模型靠梯度下降更新参数：w=w−lr×grad

训练不是全程一个学习率：

• 前期：大学习率，快速收敛
• 后期：减小学习率，精细微调、稳住最低点

autograd 算梯度 → 学习率控制步子大小 → **optimizer.step ()**更新权重

十一：优化器

利用反向传播算出的梯度（.grad），按照一定规则更新模型参数，让损失越来越小。

调整模型参数以最小化损失函数的算法

w=w-学习率x梯度

前向传播 → 算 Loss → 反向传播求梯度 (.grad) → 优化器更新参数

4种优化器：

1. SGD (随机梯度下降)
2. SGD + Momentum 动量（惯性：下坡越跑越快，遇到平缓地方靠惯性冲过去，不容易卡住）
3. RMSprop(给不同参数自动调学习率)
4. Adam

• SGD：只看当下坡度，一步一步挪
• Momentum：下坡有惯性，越冲越快
• Adam：不仅看坡度，还会自己调节步子大小，又快又稳

梯度告诉往哪走，学习率决定走多大步，优化器决定怎么走。

十二：正则化

给模型加约束、降复杂度、防死记硬背，专治过拟合、提升泛化能力。

1. L1、L2正则化（权重衰减）
2. Dropout（训练 时随机关掉一部分神经元（置 0））
3. BatchNorm
4. 数据增强（旋转，翻转，裁剪，调色）

optimizer=torch.optim.SGD(model.parameters(),lr=0.01,weight_decay=0.001)

十三：加载数据集（获取）

进入数据集下载官网：http://www.cs.toronto.edu/~kriz/cifar.html

1、下载：

2、解析：

import pickle
import numpy as np
import matplotlib.pyplot as plt

def unpickle(file):
    with open(file, 'rb') as fo:
        dict = pickle.load(fo, encoding='bytes')
    return dict

# CIFAR-100 100个细分类标签（必须用这个！越界的根源）
CIFAR100_FINE_LABELS = [
    'apple', 'aquarium_fish', 'baby', 'bear', 'beaver', 'bed', 'bee', 'beetle',
    'bicycle', 'bottle', 'bowl', 'boy', 'bridge', 'bus', 'butterfly', 'camel',
    'can', 'castle', 'caterpillar', 'cattle', 'chair', 'chimpanzee', 'clock',
    'cloud', 'cockroach', 'couch', 'crab', 'crocodile', 'cup', 'dinosaur',
    'dolphin', 'elephant', 'flatfish', 'forest', 'fox', 'girl', 'hamster',
    'house', 'kangaroo', 'keyboard', 'lamp', 'lawn_mower', 'leopard', 'lion',
    'lizard', 'lobster', 'man', 'maple_tree', 'motorcycle', 'mountain', 'mouse',
    'mushroom', 'oak_tree', 'orange', 'orchid', 'otter', 'palm_tree', 'pear',
    'pickup_truck', 'pine_tree', 'plain', 'plate', 'poppy', 'porcupine',
    'possum', 'rabbit', 'raccoon', 'ray', 'road', 'rocket', 'rose',
    'sea', 'seal', 'shark', 'shrew', 'skunk', 'skyscraper', 'snail', 'snake',
    'spider', 'squirrel', 'streetcar', 'sunflower', 'sweet_pepper', 'table',
    'tank', 'telephone', 'television', 'tiger', 'tractor', 'train', 'trout',
    'tulip', 'turtle', 'wardrobe', 'whale', 'willow_tree', 'wolf', 'woman',
    'worm'
]


# 读取数据集
import glob
train_list = glob.glob("E:/数据集/cifar-100-python/train")
print("找到文件：", train_list)

data = unpickle(train_list[0])
print("数据键：", data.keys())
print("图片形状：", data[b'data'].shape)
print("标签数量：", len(data[b'fine_labels']))


# 3. 取出一张图片并显示
im_idx = 0  # 取第0张图片
im_data = data[b'data'][im_idx]
im_data = im_data.reshape(3, 32, 32).transpose(1, 2, 0)  # 转成正常图片格式

# 4. 显示图片 + 正确标签
plt.figure(figsize=(3,3))
plt.imshow(im_data)
plt.title(CIFAR100_FINE_LABELS[data[b'fine_labels'][im_idx]])  # 正确索引
plt.axis('off')
plt.show()

补充：vscode固定开始虚拟环境

1. Ctrl + Shift + P
2. 上方输入框，输入Python: Select Interpreter（>这个符号是要的）
3. 找到需要的环境（比如：pytorch，点击，即设置为默认环境）

举例命令：

激活环境：conda activate pytorch

查看环境：conda info --env