多GPU训练实战:解决CUDA内存溢出与GPU0独占问题

多个gpu训练方法以及为何运行程序只gpu0运行(CUDA out of memory. Tried to allocate) 一,多个gpu训练方法 如果gpu还不错,不要改batchsize 一,这种方法偶尔有用,但是如果在别的地方使用了别的方法指定gpu,还是会只使用gpu0 import os os.environ['CUDA_VISIBLE_DEVICES'] = '1,2' 二,这种效果最弱 CUDA_VISIBLE_DEVICES=1,2 python train.py 三,最好用的、绝对不会出错的device,缺点是只能指定一个,或者说用这种方法我不会指定多个gpu 二,为什么设置了在多个gpu运行,但是只有g 阅读详情

1. 多GPU训练:从入门到“翻车”的必经之路

朋友们,不知道你们有没有过这样的经历:看着实验室里一排排亮着绿灯的GPU,心里盘算着这次训练能快多少倍,结果代码一跑起来,要么直接给你来个“CUDA out of memory”,要么就是眼睁睁看着只有第一块卡(GPU0)在吭哧吭哧干活,其他卡都在“围观”,负载为0。那种感觉,就像你买了一台八核的电脑,结果发现它只用了一个核心在算圆周率,剩下的七个在“思考人生”。

我刚开始搞多GPU训练的时候,几乎把能踩的坑都踩了一遍。最经典的就是,明明在代码里用 os.environ[‘CUDA_VISIBLE_DEVICES’] = ‘0,1,2,3’ 指定了四块卡,torch.cuda.device_count() 也乖乖地返回了4,但 nvidia-smi 一看,好家伙,只有GPU0的内存使用率在飙升,温度在升高,其他三块卡稳如泰山,岁月静好。紧接着,程序就报错了:RuntimeError: CUDA out of memory. Tried to allocate ... (GPU 0; ...)。问题就出在这里,你以为的“多卡并行”,很可能只是“单卡负重前行”,其他卡根本没被真正调用起来。

这篇文章,我就想以一个过来人的身份,跟你好好聊聊多GPU训练里这两个最磨人的“鬼”:内存溢出(OOM)和GPU0独占。我不会只给你扔几个代码片段就完事,我会带你弄清楚它们为什么发生,背后有哪些“潜规则”,以及怎么用最实在、最一劳永逸的方法解决掉它们。我们的目标很简单:让你手头所有的GPU都能真正动起来,把算力榨干,而不是让昂贵的硬件沦为机箱里的装饰灯。

2. 诊断篇:你的多GPU训练真的“多”起来了吗?

在急着改代码之前,我们得先学会看病。很多朋友一看到OOM报错,第一反应就是去调小 batch_size。这当然是一种方法,但往往是治标不治本,而且可能会影响模型最终的收敛效果。更关键的是,你可能根本没发现问题的根源是GPU0在“独揽大权”。

2.1 如何准确判断GPU使用情况?

命令行里输入 nvidia-smi,这是我们最忠实的朋友。但看它也有讲究,不能只看一眼了事。

  1. 看进程(PID):这是最直接的证据。在 nvidia-smi 的输出表格里,找到 Processes: 部分。这里会列出每个GPU上正在运行的进程及其PID。如果你的Python训练脚本只在GPU0下面有一个进程,而在GPU1、GPU2下面空空如也,或者只有一些无关的系统进程,那铁定就是GPU0独占问题了。
  2. 看显存(Memory-Usage)和利用率(GPU-Util):即使有进程分布在多个GPU上,也要看它们的利用率。理想的多卡训练下,所有指定GPU的显存占用应该比较均衡,并且 GPU-Util 这个百分比应该都比较高(比如90%以上),表示计算核心在忙碌。如果其他卡的利用率长期是0%或个位数,那它们很可能只是在“待命”,并没有参与实际计算。

一个更动态的观察方法是使用 watch -n 1 nvidia-smi 命令,它会每秒刷新一次状态,你能清晰地看到训练开始后,各个GPU的显存和利用率是如何变化的。

2.2 理解“CUDA_VISIBLE_DEVICES”的障眼法

这里有一个非常重要的概念,也是很多人困惑的来源:CUDA_VISIBLE_DEVICES 环境变量设置的是“可见性”,而不是“使用性”。

当你设置 os.environ[‘CUDA_VISIBLE_DEVICES’] = ‘1,2’ 或者通过命令行 CUDA_VISIBLE_DEVICES=1,2 python train.py 时,你做的事情是:对当前这个Python进程(和它启动的子进程)来说,物理上的GPU1和GPU2被“重命名”为了逻辑上的GPU0和GPU1。

换句话说,在你的代码里,torch.cuda.device_count() 会返回2,torch.cuda.get_device_name(0) 返回的会是物理GPU1的名字。但是,这仅仅意味着你的程序“能看到”这两块卡,并不代表你的模型会自动把计算分布到这两块卡上! 如果你的模型还是用老方法 model.cuda() 或者 model.to(‘cuda’),它默认只会跑到逻辑上的第一块卡,也就是物理的GPU1上去。这就是为什么你指定了多卡,却只看到一块卡有活动的原因之一。

3. 实战解决GPU0独占问题

知道了病因,我们就可以对症下药了。让模型真正跑在多块GPU上,主流有两种方法:nn.DataParallel(DP) 和 nn.parallel.DistributedDataParallel(DDP)。原始文章里提到了DP但遇到了梯度问题,我们这里把两者都讲透。

3.1 方法一:nn.DataParallel (DP) - 快速上手但有限制

DataParallel 是PyTorch提供的最简单的多GPU并行方式。它的原理非常直观:数据并行。假设你有2块GPU,batch_size 为64。DP会先把这64个样本平均分成2份(每份32个),分别送到两块GPU上做前向传播和损失计算。然后,它会把其中一块GPU(默认是第0块,也就是你逻辑上的GPU0)作为“主卡”,收集来自所有GPU的梯度,在主卡上求平均并进行反向传播、参数更新。最后,把更新后的模型参数同步到所有GPU上。

基本用法如下:

import torch
import torch.nn as nn

# 假设你的模型已经定义好了
model = MyAwesomeModel()

# 指定你想要使用的GPU设备ID(这里是逻辑ID,对应你设置的CUDA_VISIBLE_DEVICES)
device_ids = [0, 1, 2] # 使用逻辑上的前3块GPU

# 用DataParallel包装模型
if torch.cuda.device_count() > 1:
    print(f“使用 {torch.cuda.device_count()} 块GPU进行训练”)
    model = nn.DataParallel(model, device_ids=device_ids)

# 将模型移动到设备上(通常只需要移到‘cuda’,DP会自动处理)
model = model.cuda() # 或者 model.to(‘cuda’)

# 你的数据也需要放到cuda上
inputs, labels = inputs.cuda(), labels.cuda()

看起来很简单,对吧?但为什么原始文章的作者用了 nn.DataParallel 却报错了呢?很可能他遇到了DP的几个经典“坑”:

  1. 模型中有不可并行的层或操作:比如某些自定义的层在 forward 过程中包含了 print 语句,或者有对 batch 维度进行特殊操作的代码(例如 torch.bmm 在某些特定形状下)。DP在拆分和合并数据时,可能会破坏这些操作的前提条件。
  2. 梯度同步问题:这是更常见的问题。DP的梯度同步依赖于 torch.distributed 的后端,如果环境没有正确配置,或者模型中有不参与梯度计算的变量(requires_grad=False),可能会在同步时出现尺寸不匹配的错误。
  3. GPU0负载不均衡:正如原理所说,GPU0作为主卡,承担了梯度聚合和参数更新的任务,因此它的显存占用和计算负载通常会比其他卡高一些。在模型很大或 batch_size 很大时,GPU0很容易成为瓶颈并率先OOM。

所以,DP的适用场景是:模型相对规整,没有太特殊的操作,并且GPU之间显存差距不大,用于快速原型验证和小规模多卡训练。

3.2 方法二:nn.parallel.DistributedDataParallel (DDP) - 工业级首选

如果你被DP的各种问题困扰,或者想要更高效、更可扩展的多GPU训练,那么 DistributedDataParallel (DDP) 是你必须掌握的技能。DDP也是数据并行,但它的实现方式更“分布式”:每个GPU上都运行一个独立的进程,每个进程拥有模型的一个完整副本,处理数据的一个子集(batch的一部分)。 梯度同步通过进程间通信(IPC)在所有进程间进行,不再依赖一个主卡。

DDP的优势非常明显:

  • 负载更均衡:没有主卡瓶颈,每个GPU的计算和显存占用几乎一致。
  • 效率更高:通信开销经过优化,通常比DP更快。
  • 可扩展性更强:轻松支持多机多卡训练。
  • 更稳定:避免了DP中一些奇怪的数据打包/解包问题。

DDP的使用步骤稍多,但套路固定:

# train.py (每个GPU进程都会运行这个脚本)
import torch
import torch.nn as nn
import torch.distributed as dist
import torch.multiprocessing as mp
from torch.nn.parallel import DistributedDataParallel as DDP
import os

def main(rank, world_size):
    # 1. 初始化进程组
    os.environ[‘MASTER_ADDR’] = ‘localhost’ # 单机多卡,地址是本地
    os.environ[‘MASTER_PORT’] = ‘12355’     # 选择一个空闲端口
    dist.init_process_group(“nccl”, rank=rank, world_size=world_size) # 使用NCCL后端

    # 2. 为每个进程设置当前使用的GPU
    torch.cuda.set_device(rank)

    # 3. 创建模型并移到当前GPU
    model = MyAwesomeModel().cuda()

    # 4. 用DDP包装模型
    model = DDP(model, device_ids=[rank])

    # 5. 准备数据加载器,需要使用DistributedSampler
    dataset = YourDataset()
    sampler = torch.utils.data.distributed.DistributedSampler(
        dataset, num_replicas=world_size, rank=rank, shuffle=True
    )
    dataloader = torch.utils.data.DataLoader(
        dataset, batch_size=64, sampler=sampler, num_workers=4
    )

    # 6. 正常的训练循环
    for epoch in range(num_epochs):
        sampler.set_epoch(epoch) # 很重要,保证每个epoch的shuffle不同
        for data, target in dataloader:
            data, target = data.cuda(), target.cuda()
            output = model(data)
            loss = criterion(output, target)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

    # 7. 清理进程组
    dist.destroy_process_group()

if __name__ == “__main__”:
    world_size = torch.cuda.device_count() # 使用所有可用的GPU
    mp.spawn(main, args=(world_size,), nprocs=world_size)

启动命令也需要改变: 以前你可能用 python train.py,现在对于DDP,更标准的启动方式是使用PyTorch自带的 torchrun(推荐):

# 假设有4块GPU
torchrun --nproc_per_node=4 train.py

或者老式的 python -m torch.distributed.launch:

python -m torch.distributed.launch --nproc_per_node=4 train.py

这两个命令会自动帮你启动4个进程,并设置好 RANK 和 WORLD_SIZE 等环境变量。

DDP虽然步骤多,但一旦配置好,几乎能一劳永逸地解决GPU0独占和负载不均的问题,并且是当前学术研究和工业部署的标配。 我强烈建议,只要你的训练涉及到2块及以上GPU,就直接从DDP开始。

4. 攻克CUDA内存溢出(OOM)难题

解决了GPU独占问题,让所有卡都跑起来,我们常常会遇到下一个挑战:内存溢出。即使负载均衡了,每块卡上的显存可能还是不够用。别急着砍 batch_size,试试下面这几招。

4.1 模型层面:精简你的模型

首先,审视一下你的模型是不是“太胖了”。

  • 检查参数数量:像原始文章里提到的,用一个函数统计模型参数量。一个动辄几亿参数的模型,即使用上混合精度训练,单卡显存占用也可能非常惊人。
    def count_parameters(model):
        return sum(p.numel() for p in model.parameters() if p.requires_grad)
    print(f‘Total trainable params: {count_parameters(model):,}’)
    
  • 使用更高效的架构:比如用深度可分离卷积(Depthwise Separable Conv)替代标准卷积,用线性注意力(Linear Attention)替代标准注意力,这些都能在基本不影响性能的前提下大幅减少参数量和计算量。
  • 梯度检查点(Gradient Checkpointing):这是一个用时间换空间的经典技术。它在前向传播时只保存部分中间结果(检查点),而不是全部。在反向传播需要时,再根据检查点重新计算这部分前向过程。PyTorch中可以通过 torch.utils.checkpoint 轻松实现。
    from torch.utils.checkpoint import checkpoint
    
    def custom_forward(x):
        # 定义你的一段前向计算
        return some_layers(x)
    
    # 在前向传播中使用
    x = checkpoint(custom_forward, x) # 这会节省custom_forward内部的激活值显存
    

4.2 数据与训练策略层面

  • 梯度累积(Gradient Accumulation):这是在不改变模型、不减少单次输入数据量的前提下,模拟更大 batch_size 效果的利器。原理是让模型连续进行多次前向和反向传播,但不立即更新参数(optimizer.step()),而是累积这多次的梯度。当累积步数达到预设值时,再用累积的总梯度更新一次参数。

    accumulation_steps = 4 # 累积4步
    optimizer.zero_grad()
    for i, (data, target) in enumerate(dataloader):
        output = model(data)
        loss = criterion(output, target)
        loss = loss / accumulation_steps # 损失按累积步数缩放
        loss.backward() # 梯度累积
    
        if (i+1) % accumulation_steps == 0:
            optimizer.step() # 每累积4步,更新一次参数
            optimizer.zero_grad() # 清空梯度
    

    这样做,在效果上等价于使用了4倍大的 batch_size,但显存占用仅仅是一个小 batch_size 的水平。这是解决OOM最常用、最有效的技巧之一。

  • 混合精度训练(Automatic Mixed Precision, AMP):现代GPU(如Volta架构及以后的NVIDIA GPU)对半精度浮点数(float16, FP16)有专门的硬件加速单元,计算速度快,而且显存占用只有单精度(float32, FP32)的一半。AMP会自动管理哪些操作用FP16(更快,省显存),哪些必须用FP32(保持数值稳定性)。

    from torch.cuda.amp import autocast, GradScaler
    
    scaler = GradScaler() # 梯度缩放,防止FP16下梯度下溢
    for data, target in dataloader:
        optimizer.zero_grad()
        with autocast(): # 自动混合精度上下文
            output = model(data)
            loss = criterion(output, target)
        scaler.scale(loss).backward() # 缩放损失
        scaler.step(optimizer)        # 缩放梯度并更新
        scaler.update()               # 更新缩放因子
    

    混合精度训练通常能减少30%-50%的显存占用,并显著提升训练速度,几乎是现代深度学习训练的必备技能。

4.3 系统与配置层面

  • 及时清理缓存:PyTorch的CUDA内存分配器会缓存一些内存以加速后续分配。有时在长时间运行或进行大量可变尺寸运算后,缓存会变得臃肿。可以在每个epoch结束后或内存紧张时手动清理:

    torch.cuda.empty_cache()
    

    注意,这只是一个建议,不是强制命令,CUDA驱动不一定立即释放。

  • 使用pin_memory和num_workers加速数据加载:虽然这不直接减少训练时的峰值显存,但可以防止数据加载成为瓶颈,避免GPU因为等待数据而空闲,从而让GPU内存的利用率曲线更平滑。在DataLoader中设置 pin_memory=True 并合理增加 num_workers(通常设为CPU核心数或2-4倍)。

    dataloader = DataLoader(dataset, batch_size=64, shuffle=True,
                            num_workers=4, pin_memory=True)
    

5. 综合调试与高级技巧

把上面的方法组合起来,你已经能解决99%的多GPU训练问题了。这里再分享几个调试和进阶的心得。

如何定位OOM发生的具体位置? PyTorch的OOM报错信息有时不够具体。你可以使用 torch.cuda.memory_summary() 来打印更详细的内存分配情况。更好的方法是使用 torch.cuda.memory_allocated() 和 torch.cuda.max_memory_allocated() 在代码的关键位置打点,监控显存的变化。

print(f‘当前已分配显存: {torch.cuda.memory_allocated(0)/1024**3:.2f} GB’)
print(f‘峰值已分配显存: {torch.cuda.max_memory_allocated(0)/1024**3:.2f} GB’)

关于DataParallel中device_ids和output_device 在DP中,device_ids 指定了用于并行计算的GPU列表。output_device 指定了输出结果所在的设备,默认为 device_ids[0],这就是主卡负载高的原因。如果你非要用DP,并且其他卡显存更大,可以尝试将 output_device 设为其他卡,但要注意数据移动的开销。

DDP中的注意事项

  • DistributedSampler:必须使用,它保证了每个进程看到的是数据全集的不同部分,且不重复。
  • sampler.set_epoch(epoch):在每个epoch开始时调用,以确保每个epoch的数据打乱顺序不同,这对模型泛化很重要。
  • 保存和加载模型:在DDP中,由于每个进程都有完整的模型,你只需要在其中一个进程(通常是rank 0)上保存模型即可。加载时,也需要先初始化DDP环境,再用 module 属性来获取原始模型状态。
    # 保存 (在rank 0进程)
    if dist.get_rank() == 0:
        torch.save(model.module.state_dict(), ‘model.pth’)
    # 加载
    model = DDP(MyModel().cuda(), device_ids=[rank])
    model.module.load_state_dict(torch.load(‘model.pth’))
    

最后,我想说,多GPU训练初期的调试确实会让人头疼,但一旦打通,那种所有显卡风扇齐鸣、算力拉满的感觉是非常畅快的。从简单的 DataParallel 到强大的 DistributedDataParallel,从手动调 batch_size 到熟练运用梯度累积和混合精度,这个过程也是你深度学习工程能力成长的见证。我的经验是,对于新项目,如果卡数>=2,直接上DDP+AMP的组合,并合理使用梯度累积,这能为你省去大量后期调试的麻烦。希望这些实实在在的“踩坑”经验和解决方案,能帮你更快地让手头的GPU资源物尽其用。

解决:RuntimeError: CUDA out of memory. Tried to allocate 128.00 MiB (GPU 0; 2.00 GiB total capacity; 1 1. 问题2. 分析3. 解决 1. 问题 训练模型时报错: RuntimeError: CUDA out of memory. Tried to allocate 128.00 MiB (GPU 0; 2.00 GiB total capacity; 1.49 GiB already allocated; 57.03 MiB free; 6.95 MiB cached) 2. 分析 这种问题,是GPU内存不够引起的 3. 解决 方法一: 换高性能高显存的显卡 方法二:修改代码 报错的训练代码为. 阅读详情

相关推荐

使用多卡GPU训练时遇到的错误

使用多卡GPU训练时遇到的错误

Z20040913sheng的博客 1856

Windows系统下,电脑有nvidia的GPU,但是torch.cuda.device_count()显示GPU数量为0

为了配合学习李沐的《动手学深度学习 PyTorch版》,近期在Win 10系统的笔记本电脑中完成了相关配置。笔记本电脑配有nvidia 3060的显卡。学习到第5章的GPU计算时,尝试运行torch.cuda.device_count(),返回GPU数目为0。为了解决这个问题,依次进行了以下操作。

heshan1109的博客 3748

报错torch.OutOfMemoryError: CUDA out of memory...CUDA 内存溢出如何解决?

🏆 本文收录于《全栈Bug调优(实战版)》专栏,致力于分享我在项目实战过程中遇到的各类Bug及其原因,并提供切实有效的解决方案。无论你是初学者还是经验丰富的开发者,本文将为你指引出一条更高效的Bug修复之路,助你早日登顶,迈向财富自由的梦想🚀!同时,欢迎大家关注、收藏、订阅本专栏,更多精彩内容正在持续更新中。让我们一起进步,Up!Up!Up!    备注: 部分问题/难题源自互联网,经过精心筛选和整理,结合数位十多年大厂实战经验资深大佬经验总结所得,数条可行方案供所需之人参考。

**My Coding Family** 1507

深度学习跑模型,关于电脑出现GPU0和1?

深度学习跑模型,关于电脑出现GPU0和1?

weixin_50557558的博客 1万+

解决Mask RCNN训练时GPU内存溢出问题

首先自己是个小白对于如何使用GPU跑程序这个学习了一下: (1)使用的是putty,安装了Anaconda这个IDE环境,用的conda install tensorflow-gpu安装的GPU版本tf,之前只是安装了tf并没有选择GPU版本。安装完GPU版本的tf,可以进入python环境导入import tensorflow as tf 进行测试一下,如果没有报错即为成功。 (2)并在自己...

m0_37957160的博客 9049

V93000 SmarTest 8入门:从零搭建你的第一个半导体测试程序

半导体测试是芯片从设计走向量产的关键环节,而ATE(自动化测试设备)正是支撑这一环节的核心工具。理解ATE测试程序开发的基本原理,不仅需要掌握测试机台的硬件架构,还要熟悉其软件环境中的管脚映射、电平时序、测试流程等底层逻辑。V93000作为爱德万的主力平台,其SmarTest 8环境通过对象化与流程化设计,将复杂的芯片测试任务拆解为可配置、可复用的模块,极大提升了并行测试效率与调试的便利性。无论是数字逻辑芯片的功能验证,还是模拟混合信号器件的参数测量,掌握SmarTest 8的核心操作都能帮助你快速搭建出可

weixin_31476015的博客 249

os.environ[‘CUDA_VISIBLE_DEVICES‘]指定GPU后,还是用的“0“卡

我们经常需要指定特定的GPU设备来进行计算。然而,有时尽管已经设置了`CUDA_VISIBLE_DEVICES`环境变量,程序仍然会默认使用GPU设备“0”。本文将深入探讨这个问题,并提供相应的解决方案。

创作高质量博文,分享知识,共同进步! 9505

RK3588与FPGA高速PCIe通信:从理论带宽到实战优化的全流程解析

本文深入解析了瑞芯微RK3588与FPGA之间基于PCIe Gen2的高速通信全流程。从理论带宽计算(约1640MB/s)出发,详细拆解了硬件连接、驱动加载、DMA配置等关键步骤,并重点分享了中断优化、内存管理及高级调优等实战技巧,旨在帮助开发者从“跑通”到“跑好”,实现接近理论极限的稳定高效数据传输。

weixin_29175469的博客 337

多GPU训练实战:解决CUDA内存溢出与设备分配难题

本文深入探讨了多GPU训练中常见的CUDA内存溢出与设备分配难题,提供了从环境配置到高级优化的实战解决方案。详细解析了DataParallel与DistributedDataParallel的适用场景与陷阱,并重点介绍了梯度累积、混合精度训练等核心技巧来有效解决CUDA out of memory问题,帮助开发者实现高效稳健的多卡训练。

f0g1h2的博客 695

Matlab实战:用DQN算法让机器人学会自主避障(附完整代码)

本文详细介绍了如何使用Matlab实现DQN(深度Q网络)算法,使机器人在复杂环境中学会自主避障。通过环境建模、网络架构设计、奖励函数优化及实战调试,提供了完整的代码实现和训练策略,帮助开发者快速应用于机器人路径规划项目。

t8u9v0w1x的博客 234

红外与可见光融合避坑指南:LLVIP数据集实测6大算法效果对比

本文基于专为弱光视觉设计的LLVIP数据集,对GTF、DenseFuse、FusionGAN、IFCNN等6种主流红外与可见光图像融合算法进行了深度实测与对比。通过客观指标与可视化分析,揭示了算法在极端弱光下易出现特征丢失的共性问题,并探讨了融合图像对下游目标检测任务的实际增益,为工程选型与算法调优提供了实用指南。

weixin_29092031的博客 441

解决Ultralytics YOLO多GPU训练中的CUDA内存溢出问题:从原理到实战方案

你是否在使用多GPU训练YOLO模型时频繁遭遇"CUDA out of memory"错误?本文将深入分析内存溢出的根本原因,并提供6种经过实战验证的解决方案,帮助你在保持训练效率的同时彻底解决内存瓶颈。 ## 内存溢出的三大罪魁祸首 多GPU环境下的内存溢出往往不是单一因素造成的,通过分析[ultralytics/engine/trainer.py](https://link.gitcode...

gitblog_00136的博客 569

Pyinstaller打包为可执行文件编码错误的问题

Pyinstaller打包为可执行文件编码错误的问题 写好的python程序在vscode上运行没有任何问题,将程序利用pyinstaller打包后,运行程序发生了错误。 错误代码 UnicodeDecodeError: ‘utf-8' codec can't decode byte 0xce in position 20-21:invalid cotinuation byte 网上找到的解决方案是: 1.在命令行中输入 chcp 65001 2.按正常方式进行封装 pyinstaller

xuefeng_he的博客 1560

ctf-wiki 本地部署指南:4 条命令从零搭建离线 CTF 知识库

CTF Wiki 是一个免费的 CTF 学习知识库,覆盖 Web、密码学、逆向、pwn 四大方向。本地部署只需 4 条核心命令,完成后即可在 http://127.0.0.1:8008 离线浏览全部教程。 [![CTF Wiki 本地部署站点示例:CTF 比赛网络拓扑图](https://raw.gitcode.com/gh_mirrors/ct/ctf-wiki/raw/b80b319c809

gitblog_00499的博客 920

撸毛笔记-朴朴超市 v1.01

朴朴超市 v1.01脚本地址:自动签到和组队赚朴分, 朴分可以抵扣50%的金额组队瓜分需要4人成团, 每个号每天只能开团和入队各一次每天跑一两次即可使用扫码或自己想办法捉refreshToken扫码获取token: (先微信进入朴朴超市小程序并登录注册过账号再扫码)把获取的refreshToken和备注(非必须)填到文件pupuCookie.txt里(第一次运行会自动创建), 多账号换行或&或@隔开。

xiaoshun007的专栏 1814

【从零开始学习SLAM】官方tf教程小海龟跟随程序

ros tf 进行坐标系之间转换的运算和发布

小秋 AI SLAM 入门实战教程 2035

pytorch的多gpu训练

1.多GPU训练,出现out of memory 出现情景:预训练模型是使用gpu0训练得到,然后要在多gpu的服务器上进行微调,使用gpu id为[4,5,6,7],然后出现报错如下: cuda runtime error (2) : out of memory at /pytorch/aten/src/THC/THCTensorRandom.cu:25 错误原因分析:在加载预训练模型的...

猫猫与橙子的博客 3301

通过情感分类实例 详细介绍如果借助Huggingface平台 完成Transformers模型运行(包括配置环境-tokenizer-Model-输出头-预测)

attention_mask和padding是配套使用的,当人为去修改padding的时候,也要把attention_mask里面的参数进行修改。下载Huggingface包,Huggingface可以说是一个社区,集成了很多nlp的模型、数据集、预训练权重文件等等,并且免费,只需要pip install下载即可。那么用什么做分类就选择什么输出头,就import什么东西。代码中使用了自动分词器选择,它是由checkpoint指定的预训练模型关联的,不用我们自己选择tokenizer,它自动帮我们选择好了。

LZL2020LZL的博客 1138

深入解析CUDA内存溢出: OutOfMemoryError: CUDA out of memory. Tried to allocate 3.21 GiB (GPU 0; 8.00 GiB tota

在深度学习项目中,CUDA内存溢出()是一个常见的难题,尤其在使用PyTorch框架进行大规模数据处理时。本文详细讨论了CUDA内存溢出的原因、解决方案,并提供了实用的代码示例。我们将围绕错误进行深入分析,探讨内存管理、优化技巧,以及如何有效利用环境变量来避免内存碎片化。本文内容丰富,结构清晰,旨在帮助广大AI开发者,无论是深度学习的初学者还是资深研究者,有效解决CUDA内存溢出问题。关键词包括CUDA内存溢出、PyTorch、内存管理、内存碎片化、深度学习优化等,确保容易被搜索引擎检索到。关键点说明。

猫头虎技术团队:授渔优于赠鱼,兴趣引领智慧,探索之乐尤显珍贵。商务合作+:Libin9iOak ,万粉变现+:优快云WF,猫头虎承诺每年免费为100名C站创作者做账号流量诊断服务!全网搜:猫头虎技术团队,点击文章底部名片或直接私信我一切皆可谈,快找虎哥! 8050

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

pytorch中cuda out of memory问题

在组会前一天遇到这个问题,试了各种解决办法都不可以,简直要疯辽,还等着实验结果做汇报呢…… RuntimeError: CUDA out of memory. Tried to allocate 486.00 MiB (GPU 0; 10.73 GiB total capacity; 8.78 GiB already allocated; 23.62 MiB free; 1.07 GiB cached) 就是这个问题,很奇怪,不知道那1.07GiB到底是什么占了,一样的超参数设置,之前从来没有遇到过这种问题

Acmer_future_victor的博客 2万+

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

SSD Keras多GPU训练:大规模数据集的高效训练策略

在计算机视觉领域,目标检测模型的训练往往面临计算资源需求高、训练周期长的挑战。SSD(Single Shot MultiBox Detector)作为一种流行的实时目标检测算法,当处理大规模数据集时,单GPU训练已难以满足效率需求。本文将详细介绍如何在Keras框架下利用多GPU加速SSD模型训练,帮助开发者快速掌握分布式训练的核心策略与实施步骤。 ## 多GPU训练的核心优势与挑战 多GPU

gitblog_02938的博客 1016

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

分布式训练节点配置实战:从0到1构建稳定多GPU训练环境

你是否在启动分布式训练时频繁遇到"节点通信超时"、"GPU资源分配失败"或"精度不匹配"等问题?本文将通过trl项目中的[examples/accelerate_configs](https://link.gitcode.com/i/1c33215251ff56fe76207940b406ed8c)配置文件,手把手教你如何验证和优化分布式训练环境,确保多GPU集群高效协同工作。 ## 配置文件结...

gitblog_00090的博客 1001

终极DUSt3R错误排查指南:CUDA问题与内存溢出的完整解决方案

DUSt3R是一款强大的3D视觉重建工具,但在实际使用中,新手用户常遇到CUDA错误和内存溢出问题。本文将提供简单有效的解决方案,帮助你快速定位并解决这些技术难题,让3D重建流程更加顺畅。 ## 📋 常见CUDA错误及解决方案 ### 1. CUDA设备不可用错误 当你看到"CUDA out of memory"或"CUDA device not found"错误时,首先检查CUDA设备配

gitblog_00430的博客 701

解决:RuntimeError: CUDA out of memory. Tried to allocate 64.00 MiB (GPU 0; 4.00 GiB total capacity; 2

引发pytorch:CUDA out of memory错误的原因有两个: 1.当前要使用的GPU正在被占用,导致显存不足以运行你要运行的模型训练命令不能正常运行 解决方法: 1.换另外的GPU 2.kill 掉占用GPU的另外的程序(慎用!因为另外正在占用GPU的程序可能是别人在运行的程序,如果是自己的不重要的程序则可以kill) 命令行中输入以下命令,可以查看当前正在GPU运行的程序: nvidia-smi 再根据上面显示的正在运行程序的PID,输入以下查看进程的命令,可以查看到进程的相关信息,包括

universe_R的博客 3万+

告别训练崩溃:MAE实战指南之NaN与GPU内存溢出终极解决方案

你是否曾在训练MAE(Masked Autoencoders)模型时遭遇突然崩溃?屏幕上刺眼的"Loss is nan"或"CUDA out of memory"提示是否让你束手无策?本文将系统剖析这两大常见问题的根源,并提供经过实战验证的解决方案,帮助你顺利完成模型训练。读完本文,你将掌握:NaN损失值的5大排查方向、GPU内存优化的7个实用技巧、以及基于MAE源码的参数调优指南。 ## Na...

gitblog_00770的博客 771

pytorch指定GPU后仍旧使用GPU0的解决方法

我在训练模型的时候,已经指定了使用GPU5、6进行训练,然而pytorch却强行在GPU0里占用100多M的空间,但是刚好GPU0被别人占满了,导致一直是CUDA:out of memory的状态. 这个问题跟为什么Pytorch死活要用第0块显卡–我和pytorch的恩怨情仇非常像,但是我用他的方法根本不管用,感觉我的情况跟他的应该是不相同的,所以我只能自己找问题。 我根据错误提示,发现溢出的语句是加载预训练模型参数的地方: rnet_checkpoint = torch.load('../s_resne

zhongzhh8的博客 1万+
上一篇: AXI协议中的Burst传输实战:从FIFO到RAM的3种模式详解(附避坑指南)
下一篇: 从零到一:基于STM32的超声波雾化片驱动电路设计与实现
随身带U盘
博客等级 码龄4年 31粉丝 1526原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值