如何使用 PyTorch 进行半精度训练

已于 2022-05-12 20:27:57 修改
阅读量1w 收藏 33
点赞数 6
文章标签： 神经网络 深度学习 机器学习
于 2021-12-02 10:28:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39845931/article/details/121671342
版权

原文链接（可以直接运行代码）.
在这里插入图片描述

实验： 混合精度训练对比 (GTX 3090 VS TESLA V100-SXM2)

经常有小伙伴问我 TESLA V100 显存 16GB 比 GTX 3090 的 24GB 少了 8GB，价格还一样，为啥要用 V100 呢？

drawing

使用精度低于 32 位浮点数的数字格式有很多好处。首先，它们需要 更少的内存，从而能够训练和部署更大的神经网络。其次，它们需要 更少的内存带宽，从而加快数据传输操作。第三，数学运算在降低精度的情况下 运行得更快，尤其是在具有 Tensor Core 支持该精度的 GPU 上。混合精度训练实现了所有这些好处，同时确保与全精度训练相比不会丢失特定于任务的准确性。

使用混合精度训练需要以下两个步骤：

  • 移植模型以使用 FP16 数据类型。
  • 添加损失缩放以保留较小的梯度值。

下载数据集

!featurize dataset download 12d20991-7d1a-4722-bf42-b3933bf34689

以下两个包如果自己环境没有的同学请去掉注释运行

#!pip install nvidia-ml-py3 timm

import torch
import timm
import cv2
import os
import nvidia_smi
import random

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from datetime import datetime

sns.set_theme(style="whitegrid")

df = pd.read_csv('/home/featurize/data/FMY/train.csv')
df.head(2)

在这里插入图片描述

定义 PyTorch 的 Dataset

class Dataset(torch.utils.data.Dataset):

    def __init__(self, df: pd.DataFrame):
        self.df = df

    def __getitem__(self, index: int):
        row = self.df.iloc[index]
        fn = row.image
        # 读取数据
        image = cv2.imread(os.path.join(row.path, fn))
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

        # 统一数据尺寸
        image = cv2.resize(image, (384, 512), interpolation=cv2.INTER_LINEAR)
        image = image.transpose(2, 0, 1)

        label = np.array([row.label])

        return torch.from_numpy(image).float(), torch.from_numpy(label).float()

    def __len__(self):
        return len(self.df)

创建 PyTorch 的 Dataloader

train_dataset = Dataset(df)
train_dataloader = torch.utils.data.DataLoader(
    train_dataset,
    batch_size=32,
    num_workers=8,
    shuffle=True,
    pin_memory=True
)

生成随机的样本看一看

image, label = train_dataset.__getitem__(random.randint(0, len(train_dataset)-1))
plt.imshow(image.int().permute(1, 2, 0));
print('Label:', label.int().item())

在这里插入图片描述

创建模型、优化器、损失函数

model = timm.create_model('tf_efficientnet_b0', num_classes=1).cuda()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3, momentum=0.9)
criterion = torch.nn.BCEWithLogitsLoss()
drawing

上面的这些都是为实验作准备，选择的都是较小的 b0 模型和基础的损失函数，接下来的 4 个 Cell 分别对比了

GTX 3090
  • 单精度
  • 混合精度
V100
  • 单精度
  • 混合精度

所占用的 GPU 显存以及计算速度。更重要的是让小伙伴了解如何使用 PyTorch 半精度进行训练。

实验一 GTX 3090 VS V100 （单精度）

now = datetime.now()
start_time = now.strftime("%H:%M:%S")
print("Start Time =", start_time)

for epoch in range(1):

    running_loss = 0.0
    for i, data in enumerate(train_dataloader):
        # get the inputs; data is a list of [inputs, labels]
        inputs, labels = data
        inputs, labels = inputs.cuda(), labels.cuda()

        optimizer.zero_grad()

        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 100 == 99:    # print every 100 mini-batches
            print(f'Epoch: {epoch + 1} Iterations: {i + 1} Loss: {running_loss}')
            running_loss = 0.0

print('Finished Training')

now = datetime.now()
finish_time = now.strftime("%H:%M:%S")
print("Finish Time =", finish_time)

nvidia_smi.nvmlInit()
handle = nvidia_smi.nvmlDeviceGetHandleByIndex(0)
info = nvidia_smi.nvmlDeviceGetMemoryInfo(handle)

print("Total memory:", info.total)
print("Free memory:", info.free)
print("Used memory:", info.used)
print("GPU: ", nvidia_smi.nvmlDeviceGetName(handle))

nvidia_smi.nvmlShutdown()

在这里插入图片描述

now = datetime.now()
start_time = now.strftime("%H:%M:%S")
print("Start Time =", start_time)

for epoch in range(1):

    running_loss = 0.0
    for i, data in enumerate(train_dataloader):
        # get the inputs; data is a list of [inputs, labels]
        inputs, labels = data
        inputs, labels = inputs.cuda(), labels.cuda()

        optimizer.zero_grad()

        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 100 == 99:    # print every 100 mini-batches
            print(f'Epoch: {epoch + 1} Iterations: {i + 1} Loss: {running_loss}')
            running_loss = 0.0

print('Finished Training')

now = datetime.now()
finish_time = now.strftime("%H:%M:%S")
print("Finish Time =", finish_time)

nvidia_smi.nvmlInit()
handle = nvidia_smi.nvmlDeviceGetHandleByIndex(0)
info = nvidia_smi.nvmlDeviceGetMemoryInfo(handle)

print("Total memory:", info.total)
print("Free memory:", info.free)
print("Used memory:", info.used)
print("GPU: ", nvidia_smi.nvmlDeviceGetName(handle))

nvidia_smi.nvmlShutdown()

在这里插入图片描述

drawing 上面的训练可以看到
GTX 3090
  • 显存占用：14205845504
  • 计算耗时：114 秒
V100
  • 显存占用：13943701504
  • 计算耗时：122 秒

V100 单精度计算略慢于 GTX 3090

实验二 GTX 3090 VS V100 （半精度）

scaler = torch.cuda.amp.GradScaler()
autocast = torch.cuda.amp.autocast

now = datetime.now()
current_time = now.strftime("%H:%M:%S")
print("Start Time =", current_time)

for epoch in range(1):
    running_loss = 0.0
    for i, data in enumerate(train_dataloader):
        inputs, labels = data
        inputs, labels = inputs.cuda(), labels.cuda()

        optimizer.zero_grad()

        with autocast():
            outputs = model(inputs)
            loss = criterion(outputs, labels)

        scaler.scale(loss).backward()

        scaler.step(optimizer)

        scaler.update()
        running_loss += loss.item()
        if i % 100 == 99:    # print every 100 mini-batches
            print(f'Epoch: {epoch + 1} Iterations: {i + 1} Loss: {running_loss}')
            running_loss = 0.0

now = datetime.now()
current_time = now.strftime("%H:%M:%S")
print("Finish Time =", current_time)

nvidia_smi.nvmlInit()
handle = nvidia_smi.nvmlDeviceGetHandleByIndex(0)
info = nvidia_smi.nvmlDeviceGetMemoryInfo(handle)

print("Total memory:", info.total)
print("Free memory:", info.free)
print("Used memory:", info.used)
print("GPU: ", nvidia_smi.nvmlDeviceGetName(handle))

nvidia_smi.nvmlShutdown()

在这里插入图片描述

scaler = torch.cuda.amp.GradScaler()
autocast = torch.cuda.amp.autocast

now = datetime.now()
current_time = now.strftime("%H:%M:%S")
print("Start Time =", current_time)

for epoch in range(1):
    running_loss = 0.0
    for i, data in enumerate(train_dataloader):
        inputs, labels = data
        inputs, labels = inputs.cuda(), labels.cuda()

        optimizer.zero_grad()

        with autocast():
            outputs = model(inputs)
            loss = criterion(outputs, labels)

        scaler.scale(loss).backward()

        scaler.step(optimizer)

        scaler.update()
        running_loss += loss.item()
        if i % 100 == 99:    # print every 100 mini-batches
            print(f'Epoch: {epoch + 1} Iterations: {i + 1} Loss: {running_loss}')
            running_loss = 0.0

now = datetime.now()
current_time = now.strftime("%H:%M:%S")
print("Finish Time =", current_time)

nvidia_smi.nvmlInit()
handle = nvidia_smi.nvmlDeviceGetHandleByIndex(0)
info = nvidia_smi.nvmlDeviceGetMemoryInfo(handle)

print("Total memory:", info.total)
print("Free memory:", info.free)
print("Used memory:", info.used)
print("GPU: ", nvidia_smi.nvmlDeviceGetName(handle))

nvidia_smi.nvmlShutdown()

在这里插入图片描述

drawing 这次的训练可以看到
GTX 3090
  • 显存占用：9092988928
  • 计算耗时：144 秒
V100
  • 显存占用：8084258816
  • 计算耗时：90 秒

V100 半精度远高于 GTX 3090 的半精度计算

🎉 半精度训练极大得节约了 GPU 显存，显存占用从之前的 14 GB 左右降低到了 8-9 GB 🎉
sns.barplot(
    x=[
        '3090 FP32',
        'V100 FP32',
        '3090 FP16',
        'V100 FP16'],
    y=[
        14205845504,
        13954187264,
        9092988928,
        8084258816]
).set_title('GPU Memory');

在这里插入图片描述

sns.barplot(
    x=[
        '3090 FP32',
        'V100 FP32',
        '3090 FP16',
        'V100 FP16'
    ],
    y=[
        1/114,
        1/122,
        1/144,
        1/90
    ]
).set_title('Speed');

在这里插入图片描述

drawing 还不会混合精度训练的的同学尽早试一试哦，告别显存吃紧的训练。

原文链接（可以直接运行代码）.
在这里插入图片描述

image

Dave 扫地工
关注
  • 6
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
pytorch 半精度，提升pytorch推理性能
jacke121的专栏
08-20 1万+
原生的torch是float32的，我们可以借鉴模型量化的思想将其变成float16，而且pytorch自身就定义了半精度的tensor 假设我训练的一个模型为model，我们在运算的时候直接将模型转成半精度的模型，怎么做的呢？直接使用model.half()就行 model.half() model.cuda() 假设我们有个float32的tensor的变量 img，为了使用半精度的模型，同样需要将其输入转成HalfTensor img=img.type(torch.HalfTensor).cud
pytorch_img_classification_for_competition:使用pytorch进行图像分类
03-20
pytorch图像分类竞赛框架 1.更新日志 （2020年5月2日）基础版本上线 2.依赖库 预训练模型 进步 高效网络火炬 顶尖 3.支持功能 pytorch官网模型 复现的部分模型 fp16混合精度训练 贸易协定 固定验证集/随机划分验证集 多种优化器：adam，radam，novograd，sgd，ranger，ralamb，over9000，lookahead，lamb OneCycle训练策略 标签平滑丢失 焦点损失 听觉 4.使用方法 更改config.py中的参数，训练执行python main.py ，预测执行python test.py 5. Submit_example.csv 每一行：filename，label样例： 0001.jpg,dog 0002.jpg,dog 0003.jpg,dog 注：预测图像可能没有标签，所以标签可以随意给个临时的
如何使用 PyTorch 进行半精度、混(合)精度训练
qq_44089890的博客
05-03 7178
NVIDIA深度学习加速库Apex是一个用于PyTorch的开源混合精度训练工具包，旨在加速训练并减少内存使用。Apex提供了许多用于混合精度训练的工具，包括半精度浮点数（float16）支持、动态精度缩放、分布式训练等功能。Apex中最为常用的功能是半精度浮点数支持。半精度浮点数通常用于加速深度学习训练，并且可以显著减少GPU内存的使用。Apex提供了一种简单的方法来实现半精度训练，只需要在模型定义和训练循环中添加几行代码即可。
Pytorch半精度训练（以两层BP网络为例） 与正常训练对比及loss可视化
AsajuHuishi的博客
05-02 2837
Pytorch半精度训练，只需要修改以下内容： Variables: x,y = x.cuda().half(),y.cuda().half() model: model.cuda().half() 以两层累积BP网络为例，数据采用西瓜数据集3.0，分别使用全精度训练和半精度训练，发现在本文中网络很小的情况下，二者的loss曲线几乎是一样的。 另外，使用Adam优化器注意需要设置eps参数，否...
Pytorch混合精度(FP16&FP32)(AMP自动混合精度)/半精度 训练(一) —— 原理(torch.half)
hxxjxw的博客
08-19 1万+
一般用混合精度(AMP, Automatic mixed precision)，用半精度可能对acc的影响较大 混合精度的performance也要看网络，有些网络的提升不大，有些网络会影响acc AMP自动混合精度，可以在神经网络推理过程中，针对不同的层，采用不同的数据精度进行计算，从而实现节省显存和加快速度的目的。在Pytorch 1.5版本及以前，通过NVIDIA提供的apex库可以实现amp功能。但是在使用过程中会伴随着一些版本兼容和奇怪的报错问题。从...
记录PyTorch中半精度amp训练出现Nan的排查过程
xu.hyj
12-06 3261
网络的教程来看，在半精度amp训练出现nan问题，无非就是这几种：但是总结起来就三种：先说结论，我使用amp半精度训练，即中间会参杂float16数据类型，加快训练过程。但是本文出现Nan就是因为float16，因为float16支持的最大值在65504，而我的模型中涉及一个矩阵乘法（其实就是transformer中的q@k运算）。其中，a∈[-38,40]，b∈[-39,40]，而矩阵乘法a@b=c，c∈[-61408,inf]。因为a和b的矩阵乘法运算后最大值超过了float16最大表示，造成出现inf
Pytorch 分布式并行训练 + 半精度/混合精度训练
David's Tweet
07-12 9092
该博客基于以下项目的开源代码进行分析： Simple Pose: Rethinking and Improving a Bottom-up Approach for Multi-Person Pose Estimation”, accepted by AAAI-2020. Github代码地址：代码 参考： 知乎《一个 Pytorch 训练实践 （分布式训练 + 半精度/混合精度训练）》 《Pytorch + Apex 训练流程记录》 《pytorch apex 混合精度训练和horovod分.
pytorch单精度、半精度、混合精度、单卡、多卡（DP / DDP）、FSDP、DeepSpeed模型训练
胖胖大海的博客
11-17 2643
pytorch单精度、半精度、混合精度、单卡、多卡（DP / DDP）、FSDP、DeepSpeed（环境没搞起来）模型训练代码，并对比不同方法的训练速度以及GPU内存的使用
Pytorch~半精度amp训练
whaosoft143ai的博客
01-14 415
其次，由于使用了半精度，optimizer接收到了【已经因为精度损失而变为nan的loss】，nan不管加上多大的eps，都还是nan，所以optimizer也无法处理异常，最终导致网络参数nan。如果为True，那么在调用scaler方法时会做梯度缩放来调整loss，以防半精度状况下，梯度值过大或者过小从而被nan或者inf。而且，它还会判断本轮loss是否是nan，如果是，那么本轮计算的梯度不会回传，同时，当前的scale系数乘上backoff_factor，缩减scale的大小_。whaosoft
pytorch 半精度训练
qq_276982536的博客
03-24 210
实验发现从一epoch44秒，减少为35秒。这种训练直接变成nan了结果。但是训练的速度下降？
【PyTorch基础教程21】进阶训练技巧（损失函数、学习率、模型微调、半精度训练）
发现问题，并解决问题，批判性思维
03-18 3799
学习总结 自定义损失函数：函数定义、类定义（用得更多）。注意涉及到数学运算时，我们最好全程使用PyTorch提供的张量计算接口，这样就不需要我们实现自动求导功能并且我们可以直接调用cuda。 动态调整学习率：pytorch内置scheduler或者自定义scheduler。 模型微调：迁移学习的应用场景，如在目标数据集上训练目标模型，将从头训练输出层，而其余层的参数都是基于源模型的参数微调得到的。 获取pytorch中的预训练模型，冻结预训练模型中所有参数； 然后模型微调：如替换ResNet最后的2层网
基于Pytorch的UNet语义分割模型与代码
12-26
模型在FloodNet数据集上进行了训练，mIOU在0.83左右，可训练自己的数据集 建议在训练网络的时候将输入的训练集其切分为384x384的小图片后，再来进行训练 模型采用标准的UNet，可以采用如下方式训练你自己的模型 数据集地址可以在train.py中修改为你自己的文件夹 python train.py -- --epochs 20 --batch-size 16 --learning-rate 2e-4 --scale 1 --validation 0.1 --classes 10 --amp 其中--amp为半精度训练 --scale是训练的时候对图片进行缩放，已经裁剪为384x384后就不需要再裁剪了
pytorch量化感知训练（QAT）示例---ResNet
02-19
1. 训练浮点模型，测试浮点模式在CPU和GPU上的时间; 2. BN层融合，测试融合前后精度和结果比对; 3. 加入torch的量化感知API，训练一个QAT模型; 4. 保存定点INT8模型, 测试速度和精度; 5. 完成一致性对其，并保存int8模型。
inception_v1.pytorch:pytorch中具有预训练权重的inception_v1的实现
05-14
inception_v1.pytorch 在pytorch上使用预训练的权重实现inception_v1。 这段代码是soumith火炬仓库的pytorch翻译： : 它实现了初始架构的原始版本； 众所周知的是GoogLeNet。 可以在找到预训练的权重 免责声明 imagenet上预训练模型的测试精度仅为26.38％。 如果我没记错的话，这是原始火炬回购的问题-数据加载正确完成。 如果您训练此模型的准确性更高，我希望获得新的权重！ 执照 该代码是根据MIT许可证获得许可的。 有关详细信息，请参见文件。
在pytorch 中计算精度、回归率、F1 score等指标的实例
01-20
pytorch中训练完网络后，需要对学习的结果进行测试。官网上例程用的方法统统都是正确率，使用的是torch.eq()这个函数。 但是为了更精细的评价结果，我们还需要计算其他各个指标。在把官网API翻了一遍之后发现并没有...
量化加速-基于Pytorch+TVM进行低精度+混合精度的量化感知训练-附项目源码-优质项目实战.zip
最新发布
05-11
量化加速_基于Pytorch+TVM进行低精度+混合精度的量化感知训练_附项目源码_优质项目实战
pytorch 使用amp.autocast半精度加速训练
热门推荐
weixin_42216799的博客
12-08 1万+
pytorch 使用autocast半精度加速训练 如何使用autocast？ 根据官方提供的方法， 答案就是autocast + GradScaler。 1，autocast 正如前文所说，需要使用torch.cuda.amp模块中的autocast 类。使用也是非常简单的： 如何在PyTorch中使用自动混合精度？ 答案：autocast + GradScaler。 1.autocast 正如前文所说，需要使用torch.cuda.amp模块中的autocast 类。使用也是非常简单的 from tor
pytorch 半精度half()
jacke121的专栏
08-27 2729
pytorch 半精度hlaf()
Transfomrer Benchmark3090对比3090Ti(跟李沐学AI作业简化版)
m0_46339652的博客
03-11 789
环境：RTX3090Python3.9。
pytorch amp混合精度训练
05-26
PyTorch AMP（Automatic Mixed Precision）是一种混合精度训练技术，它可以在保持模型精度的前提下，加快训练速度和节省显存。AMP利用半精度浮点数（FP16）来存储权重和梯度，同时使用动态精度缩放（Dynamic Precision Scaling）技术来避免精度损失。 下面是一些使用PyTorch AMP进行混合精度训练的步骤： 1. 导入AMP模块 ```python from torch.cuda.amp import autocast, GradScaler ``` 2. 定义模型和优化器 ```python model = MyModel().to(device) optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) ``` 3. 定义GradScaler ```python scaler = GradScaler() ``` 4. 在每个训练迭代中使用autocast和GradScaler ```python for inputs, targets in data_loader: optimizer.zero_grad() with autocast(): outputs = model(inputs) loss = criterion(outputs, targets) scaler.scale(loss).backward() scaler.step(optimizer) scaler.update() ``` 在上面的代码中，我们使用autocast()将前向传递和反向传递操作包装在一个半精度环境中。然后，我们使用GradScaler来缩放loss和梯度，以避免数值下溢或上溢问题。 这些步骤可以帮助你使用PyTorch AMP进行混合精度训练。但是，需要注意的是，在使用AMP进行混合精度训练时，可能需要对你的代码进行一些修改，以避免一些潜在的数值问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Dave 扫地工

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值