Lingbot-Depth-Pretrain-ViTL-14模型推理优化降低显存占用的实战技巧你是不是也遇到过这种情况好不容易找到一个效果不错的深度估计模型比如Lingbot-Depth-Pretrain-ViTL-14兴致勃勃地准备在自己的项目里用起来结果一跑起来显卡内存就“爆”了。看着屏幕上那个“CUDA out of memory”的错误提示心里真是又急又无奈。尤其是在显存有限的个人电脑或者一些云端服务器上这个问题特别常见。模型本身能力很强但就是太“吃”显存了导致很多实际应用场景根本跑不起来。别担心今天这篇文章就是来帮你解决这个头疼问题的。我会手把手带你用几种经过实战验证的技巧来给Lingbot-Depth-Pretrain-ViTL-14模型“瘦身”让它能在更小的显存环境下顺畅运行。我们不会讲太多复杂的理论重点就是“怎么做”以及“效果怎么样”。我会用对比实验的数据让你清清楚楚地看到每种方法能省下多少显存速度是变快了还是变慢了。无论你是刚接触深度学习部署的新手还是正在为项目资源发愁的开发者这些技巧都能直接拿来用。我们的目标很简单让好用的模型能在更多地方用起来。1. 准备工作与环境搭建在开始各种“瘦身”手术之前我们得先把手术台——也就是运行环境准备好。这一步做好了后面的操作才能顺利进行。1.1 模型与基础代码首先我们需要把模型和最基本的推理代码准备好。这里假设你已经对PyTorch有基本的了解。我们从一个最“朴素”的版本开始这样后面才能看出优化带来的变化。import torch import torch.nn.functional as F from PIL import Image import requests from transformers import AutoImageProcessor, AutoModelForDepthEstimation import time # 1. 加载模型和处理器这是我们的基线版本 print(正在加载Lingbot-Depth-Pretrain-ViTL-14模型...) model_name lingbot/Depth-Pretrain-ViTL-14 processor AutoImageProcessor.from_pretrained(model_name) model AutoModelForDepthEstimation.from_pretrained(model_name).to(cuda) # 2. 准备一张示例图片 url http://images.cocodataset.org/val2017/000000039769.jpg image Image.open(requests.get(url, streamTrue).raw) # 3. 基础推理函数 def baseline_inference(image, model, processor): 最基础的推理流程用于后续对比 # 预处理图像 inputs processor(imagesimage, return_tensorspt).to(cuda) # 清空GPU缓存确保每次测试起点一致 torch.cuda.empty_cache() torch.cuda.reset_peak_memory_stats() # 记录开始时间和显存 start_time time.time() start_mem torch.cuda.memory_allocated() # 模型推理 with torch.no_grad(): outputs model(**inputs) predicted_depth outputs.predicted_depth # 后处理将深度图缩放到可视化的范围 prediction torch.nn.functional.interpolate( predicted_depth.unsqueeze(1), sizeimage.size[::-1], # (height, width) modebicubic, align_cornersFalse, ) output prediction.squeeze().cpu().numpy() output (output - output.min()) / (output.max() - output.min()) # 记录结束时间和峰值显存 end_time time.time() peak_mem torch.cuda.max_memory_allocated() inference_time end_time - start_time memory_used (peak_mem - start_mem) / 1024**2 # 转换为MB return output, inference_time, memory_used # 4. 运行一次基线测试看看“原版”模型的表现 print(\n运行基线推理测试...) depth_map, base_time, base_memory baseline_inference(image, model, processor) print(f基线结果 - 推理时间: {base_time:.2f}秒, 峰值显存占用: {base_memory:.1f} MB)把这段代码跑起来你就得到了一个参照物。记下它用了多少显存、花了多少时间。后面我们每用一种优化技巧都会和这个“原版”数据做对比。1.2 监控工具看清显存变化优化就像减肥得有个秤时刻看着。在PyTorch里我们可以用一些简单的方法来监控显存。def print_memory_stats(step_name): 打印当前GPU内存使用情况 allocated torch.cuda.memory_allocated() / 1024**2 cached torch.cuda.memory_reserved() / 1024**2 print(f[{step_name}] 已分配: {allocated:.1f} MB, 缓存: {cached:.1f} MB) # 在代码的关键步骤插入这个函数就能看到显存是怎么被用掉的 print_memory_stats(模型加载后)准备好了这些我们的“手术”就可以开始了。接下来我会介绍四种最常用、也最有效的优化技巧从简单到复杂你可以根据自己的情况选择使用。2. 技巧一使用半精度FP16推理这是最常见也通常是最先尝试的优化方法。它的原理不难理解默认情况下PyTorch模型使用FP32单精度浮点数来计算每个数字占4个字节。而FP16半精度浮点数只占2个字节。直接把模型的数据“砍掉”一半大小显存占用自然就降下来了。听起来是不是很简单但直接转换可能会遇到数值不稳定的问题比如溢出数字太大或者下溢数字太小。所以我们需要一些安全的做法。2.1 手动转换模型权重最直接的方法就是把整个模型的参数都转换成FP16格式。def fp16_inference(image, model, processor): 使用FP16半精度进行推理 # 将整个模型转换为FP16 model_fp16 model.half() # 预处理图像注意输入也需要是FP16 inputs processor(imagesimage, return_tensorspt) for key in inputs: inputs[key] inputs[key].to(cuda).half() # 监控准备 torch.cuda.empty_cache() torch.cuda.reset_peak_memory_stats() start_time time.time() start_mem torch.cuda.memory_allocated() # 推理 with torch.no_grad(): outputs model_fp16(**inputs) predicted_depth outputs.predicted_depth # 后处理注意这里可能需要转回FP32以保证精度 prediction torch.nn.functional.interpolate( predicted_depth.float().unsqueeze(1), # 转回float32进行插值 sizeimage.size[::-1], modebicubic, align_cornersFalse, ) output prediction.squeeze().cpu().numpy() output (output - output.min()) / (output.max() - output.min()) # 记录结果 end_time time.time() peak_mem torch.cuda.max_memory_allocated() inference_time end_time - start_time memory_used (peak_mem - start_mem) / 1024**2 return output, inference_time, memory_used print(\n运行FP16推理测试...) depth_fp16, time_fp16, memory_fp16 fp16_inference(image, model, processor) print(fFP16结果 - 推理时间: {time_fp16:.2f}秒, 峰值显存占用: {memory_fp16:.1f} MB)跑完这个你应该能看到显存占用有明显的下降。但这个方法有个小问题它把模型中所有的计算都变成了FP16包括一些可能对精度很敏感的操作比如层归一化。对于Lingbot-Depth这类视觉模型通常影响不大但如果你发现深度图的质量有明显下降可能需要考虑更精细的方法。2.2 只转换部分模块一个更稳妥的策略是只把模型里“大头”的部分转成FP16比如那些参数多的线性层、卷积层而把一些敏感的操作留在FP32。def selective_fp16_inference(image, model, processor): 选择性对模型部分模块使用FP16 # 我们创建一个新的模型副本避免修改原始模型 from copy import deepcopy model_selective deepcopy(model) # 只将视觉TransformerViT的主干部分转换为FP16 # 具体模块名称需要根据实际模型结构查看这里是个示例 if hasattr(model_selective, vit): model_selective.vit model_selective.vit.half() # 保持解码器头部为FP32以保证输出精度 if hasattr(model_selective, depth_head): model_selective.depth_head model_selective.depth_head.float() model_selective model_selective.to(cuda) # 预处理和推理逻辑与之前类似... # ... (这里省略重复的代码实际使用时需要完整编写)选择性转换需要你对模型结构有一定的了解但能更好地平衡显存和精度。对于Lingbot-Depth-Pretrain-ViTL-14你可以尝试只转换model.vit部分看看效果。3. 技巧二使用梯度检查点Gradient Checkpointing这个方法的名字听起来有点技术性但原理其实很“生活化”。想象一下你在解一道很长的数学题每一步都需要用到前一步的结果。如果每一步都详细写下来草稿纸很快就用完了。但如果你只记住关键几步的结果中间过程需要时再重新算一下就能省下很多草稿纸。梯度检查点就是类似的思路。在模型前向传播计算预测结果时它只保存一些关键层的输出而不是每一层的输出都保存。等到反向传播计算梯度更新模型需要用到中间结果时再根据保存的关键点重新计算那一部分的前向传播。这个方法特别适合像ViT-14这样层数比较深的模型能省下很多用来存储中间结果的显存。def checkpoint_inference(image, model, processor): 使用梯度检查点进行推理 # 注意要使用梯度检查点需要在加载模型前启用它 # 所以我们重新加载一个启用了checkpoint的模型 from transformers import AutoConfig print(重新加载启用梯度检查点的模型...) config AutoConfig.from_pretrained(model_name) config.use_cache False # 某些Transformer模型需要关闭缓存 # 关键步骤设置梯度检查点 model_checkpoint AutoModelForDepthEstimation.from_pretrained( model_name, configconfig ).to(cuda) # 启用梯度检查点 # 这里我们尝试对模型的视觉Transformer部分启用 if hasattr(model_checkpoint, vit): # transformer模型通常有多个encoder层 model_checkpoint.vit.encoder.gradient_checkpointing True print(已在ViT编码器上启用梯度检查点) # 接下来的推理代码和基线版本基本一样 inputs processor(imagesimage, return_tensorspt).to(cuda) torch.cuda.empty_cache() torch.cuda.reset_peak_memory_stats() start_time time.time() start_mem torch.cuda.memory_allocated() with torch.no_grad(): outputs model_checkpoint(**inputs) predicted_depth outputs.predicted_depth # ... 后处理部分与之前相同 ... # 计算时间和显存 end_time time.time() peak_mem torch.cuda.max_memory_allocated() inference_time end_time - start_time memory_used (peak_mem - start_mem) / 1024**2 return inference_time, memory_used print(\n运行梯度检查点推理测试...) time_checkpoint, memory_checkpoint checkpoint_inference(image, model, processor) print(f检查点结果 - 推理时间: {time_checkpoint:.2f}秒, 峰值显存占用: {memory_checkpoint:.1f} MB)这里有个重要的事情需要提醒你梯度检查点是用时间换空间。因为它需要重新计算部分前向传播所以推理速度通常会变慢一些。你需要根据实际情况权衡是显存更重要还是速度更重要。另外对于纯推理不训练的场景有些模型可能不需要梯度检查点因为with torch.no_grad()上下文管理器已经阻止了中间结果的保存。但在某些模型实现中它仍然能起到作用。最好的办法就是实际测试一下。4. 技巧三模型切片Model Sharding当模型实在太大即使用上FP16和梯度检查点一张显卡还是放不下时我们就得考虑“切片”了。这个思路很简单把模型切成几块分别放到不同的显卡上或者同一张显卡上分批处理。不过对于推理来说更实用的是一种叫做“CPU卸载”的变通方法把模型的一部分放在CPU内存里需要时才加载到GPU上。CPU内存通常比GPU显存大得多但速度会慢一些。def cpu_offload_inference(image, model, processor): 使用CPU卸载部分模型层 # 重新加载模型到CPU model_cpu AutoModelForDepthEstimation.from_pretrained(model_name) # 手动将模型的不同部分移动到不同设备 # 假设我们把前半部分放在GPU后半部分留在CPU if hasattr(model_cpu, vit): vit_layers model_cpu.vit.encoder.layer num_layers len(vit_layers) # 前70%的层放在GPU上 for i in range(int(num_layers * 0.7)): vit_layers[i] vit_layers[i].to(cuda) # 后30%的层留在CPU上 for i in range(int(num_layers * 0.7), num_layers): vit_layers[i] vit_layers[i].to(cpu) # 解码器头部放在GPU上 if hasattr(model_cpu, depth_head): model_cpu.depth_head model_cpu.depth_head.to(cuda) print(模型已切片部分层在GPU部分在CPU) # 推理函数需要处理设备转移 inputs processor(imagesimage, return_tensorspt) input_device cuda # 输入放在GPU上 for key in inputs: inputs[key] inputs[key].to(input_device) torch.cuda.empty_cache() torch.cuda.reset_peak_memory_stats() start_time time.time() start_mem torch.cuda.memory_allocated() with torch.no_grad(): # 手动执行前向传播处理设备转移 hidden_states model_cpu.vit.embeddings(**inputs) # 逐层处理 for i, layer in enumerate(model_cpu.vit.encoder.layer): current_device next(layer.parameters()).device # 如果需要转移设备 if hidden_states.device ! current_device: hidden_states hidden_states.to(current_device) hidden_states layer(hidden_states)[0] # 最后转移到GPU进行头部解码 hidden_states hidden_states.to(cuda) outputs model_cpu.depth_head(hidden_states) predicted_depth outputs.predicted_depth # ... 后处理和记录结果 ... end_time time.time() peak_mem torch.cuda.max_memory_allocated() inference_time end_time - start_time memory_used (peak_mem - start_mem) / 1024**2 return inference_time, memory_used print(\n运行CPU卸载推理测试...) time_offload, memory_offload cpu_offload_inference(image, model, processor) print(fCPU卸载结果 - 推理时间: {time_offload:.2f}秒, 峰值显存占用: {memory_offload:.1f} MB)这种方法显存节省效果最明显因为大部分模型参数都待在CPU内存里。但代价是速度会慢很多因为数据需要在CPU和GPU之间来回搬运。它适合那些对延迟要求不高但显存特别紧张的场景。5. 技巧四PyTorch AMP自动混合精度前面我们手动搞FP16虽然有效但有点麻烦而且可能不是最优的。PyTorch官方提供了一个更好的工具AMPAutomatic Mixed Precision自动混合精度。它会自动分析你的模型和计算决定哪些部分用FP16算更快更省内存哪些部分必须用FP32保证精度。AMP就像个智能管家帮你管理精度转换比我们手动操作更精细、更安全。def amp_inference(image, model, processor): 使用PyTorch AMP自动混合精度进行推理 from torch.cuda.amp import autocast inputs processor(imagesimage, return_tensorspt).to(cuda) torch.cuda.empty_cache() torch.cuda.reset_peak_memory_stats() start_time time.time() start_mem torch.cuda.memory_allocated() with torch.no_grad(): # 关键使用autocast上下文管理器 with autocast(): outputs model(**inputs) predicted_depth outputs.predicted_depth # 注意在autocast区域外张量会自动转回FP32 # 所以后处理不需要特殊处理 prediction torch.nn.functional.interpolate( predicted_depth.unsqueeze(1), sizeimage.size[::-1], modebicubic, align_cornersFalse, ) output prediction.squeeze().cpu().# 1. 两数之和 ## 题目 给定一个整数数组 nums 和一个整数目标值 target请你在该数组中找出 **和为目标值** *target* 的那 **两个** 整数并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 **示例 1**输入nums [2,7,11,15], target 9 输出[0,1] 解释因为 nums[0] nums[1] 9 返回 [0, 1] 。**示例 2**输入nums [3,2,4], target 6 输出[1,2]**示例 3**输入nums [3,3], target 6 输出[0,1]**提示** - 2 nums.length 104 - -109 nums[i] 109 - -109 target 109 - **只会存在一个有效答案** **进阶**你可以想出一个时间复杂度小于 O(n2) 的算法吗 ## 思路 使用哈希表遍历数组将数组元素作为 key下标作为 value 存入哈希表在遍历过程中判断 target - 当前元素是否在哈希表中如果在则返回当前下标和哈希表中对应的下标。 ## 代码 java class Solution { public int[] twoSum(int[] nums, int target) { MapInteger, Integer map new HashMap(); for (int i 0; i nums.length; i) { int complement target - nums[i]; if (map.containsKey(complement)) { return new int[] { map.get(complement), i }; } map.put(nums[i], i); } throw new IllegalArgumentException(No two sum solution); } }