torch.hub.load 读取本地模型

时间: 2025-01-12 21:13:37 浏览: 279
### 如何使用 `torch.hub.load` 加载本地训练的 PyTorch 模型 为了成功加载本地训练的PyTorch模型，可以采用如下方法： 当目标是从特定路径加载自定义模型时，需指定源参数为 `'local'` 并给出确切的模型文件位置。例如，在YOLOv5框架下，可以通过下面的方式实现这一操作[^1]。 ```python import torch model = torch.hub.load( 'E:/yolo/yolov5-6.0', # YOLOv5仓库所在的本地目录 'custom', # 自定义模型选项 path=r'best.pt', # 指向.pth或.pt格式的最佳权重文件的位置 source='local' # 表明从本地而不是远程服务器加载 ) # 设置置信度阈值来过滤预测结果中的低质量检测框 model.conf = 0.8 ``` 另外一种情况是如果遇到由于网络原因导致在线下载失败的情况，则应先手动获取所需的模型文件至本地存储空间后再按照上述方式调用[^2]。 值得注意的是，在执行此过程之前可能还需要确保已经安装了一些必要的依赖库以支持所使用的具体版本的YOLOv5或其他类型的深度学习项目[^3]。 对于自然语言处理领域内的应用来说，虽然主要涉及到了Hugging Face提供的NLP预训练模型，但是基本原理相同——即通过调整`source`参数指向本地资源完成离线环境下的快速部署工作[^4]。
相关问题

torch.hub.load和attempt_load

### torch.hub.load 和 attempt_load 的区别及用法 #### 1. `torch.hub.load` 的功能与实现 `torch.hub.load` 是 PyTorch 提供的一个便捷工具，用于加载来自 GitHub 上托管的预训练模型或其他资源。它通过指定仓库地址、模型名称以及额外参数来完成模型加载操作[^5]。 以下是其基本语法： ```python model = torch.hub.load(repo_or_dir, model_name, *args, **kwargs) ``` - `repo_or_dir`: 可以为一个远程 Git 仓库 URL 或本地路径。 - `model_name`: 需要加载的模型名。 - `*args`, `**kwargs`: 模型初始化所需的其他参数。 例如，从官方 YOLOv5 仓库加载模型可以这样写： ```python model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True) ``` 此方法的优点在于简单易用，适合快速原型开发或测试已发布的模型版本[^6]。 --- #### 2. `attempt_load` 的功能与实现 `attempt_load` 并不是 PyTorch 自带的方法，而是常见于某些开源项目（如 Ultralytics 的 YOLO 系列）中的自定义函数。它的主要目的是尝试加载本地保存的权重文件并构建对应的网络结构[^3]。 典型调用方式如下所示： ```python from pathlib import Path from models.common import DetectMultiBackend weights_path = "path/to/best.pt" device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = attempt_load(weights=weights_path, device=device) # 加载本地权重 ``` 该函数的核心逻辑通常包括以下几个方面： - 判断输入路径是否存在有效权重文件。 - 如果存在，则利用权重重建模型架构；如果不存在，则抛出异常提示用户检查路径设置是否正确[^7]。 相比而言，这种方法更加灵活可控，尤其适用于生产环境中部署定制化模型实例时的需求场景。 --- #### 3. 主要差异对比分析 | 特性 | `torch.hub.load` | `attempt_load` | |---------------------|------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------| | **适用范围** | 更倾向于获取公开共享的标准模型 | 多数情况下用来恢复先前训练好的特定私有模型 | | **依赖外部源码库** | 必须连接到互联网访问目标存储库 | 不需要联网即可执行 | | **灵活性** | 较低，因为受限于所选框架支持的功能集 | 极高，允许开发者自由调整内部组件 | | **性能开销** | 动态下载可能带来一定延迟 | 直接读取硬盘数据，速度更快 | 综上所述，在实际应用过程中可以根据具体需求选择合适的方案：如果是希望迅速体验最新研究成果推荐前者；而后者则更适合那些追求极致效率或者维护专属解决方案的技术人员采用[^8]。 --- ### 示例代码比较 #### 使用 `torch.hub.load` ```python import torch # 加载YOLOv5s模型 model_hub = torch.hub.load('ultralytics/yolov5', 'custom', path='best.pt', force_reload=True) img = 'https://ultralytics.com/images/zidane.jpg' results = model_hub(img) print(results.pandas().xyxy[0]) ``` #### 使用 `attempt_load` ```python from utils.general import check_img_size from models.experimental import attempt_load weights = './runs/train/exp/weights/best.pt' imgsz = 640 device = torch.device('cuda') model_attempt = attempt_load(weights, map_location=device) # 尝试加载本地PT文件 stride = int(model_attempt.stride.max()) # 输出步幅大小 imgsz = check_img_size(imgsz, s=stride) # 校验图像尺寸适配情况 ``` ---

torch.hub.load的用法

### PyTorch `torch.hub.load` 的使用方法 #### 函数定义 PyTorch 提供了 `torch.hub.load()` 方法来加载预训练模型或其他资源。此函数支持从 GitHub 或其他源代码仓库中直接下载并加载模型，也可以通过指定路径加载本地存储的模型。 其完整的参数列表如下： ```python torch.hub.load( repo_or_dir, # 存储库地址或目录路径 (字符串形式) model, # 要加载的模型名称 (字符串形式) *args, # 可变长度的位置参数 source='github', # 数据源，默认为 'github' trust_repo=None, # 是否信任远程仓库（布尔值） force_reload=False,# 是否强制重新下载模型文件 verbose=True, # 是否打印日志信息 skip_validation=False, # 是否跳过验证流程 **kwargs # 关键字参数 ) ``` --- #### 示例代码 以下是基于引用内容的一个具体示例[^1]，展示如何使用 `torch.hub.load` 加载 DINOv2 预训练模型： ```python import torch # 解决特定版本 Bug 的临时修复方案 torch.hub._validate_not_a_forked_repo = lambda a, b, c: True # 定义要加载的模型名 backbone_name = "dinov2_vits14" # 使用 torch.hub.load 下载并加载模型 backbone_model = torch.hub.load( repo_or_dir="facebookresearch/dinov2", model=backbone_name, source='github', trust_repo='check' # 自动检测仓库可信度 ) print(backbone_model) # 打印模型结构 ``` 上述代码片段展示了如何解决潜在的兼容性问题以及成功加载来自 Facebook Research 开发的 DINOv2 模型的方法。 --- #### 参数详解 - **repo_or_dir**: 表示目标模型所在的存储库 URL 或本地目录路径。如果是一个有效的 URL，则会尝试从中克隆存储库；如果是本地路径，则直接读取其中的内容。 - **model**: 这是要实例化的类或者函数的名字，在给定存储库内的 Python 文件里被定义好之后可以通过调用返回对应对象。 - **source**: 默认设置为 `'github'` ，意味着它将寻找公共可用的 GitLab/GitHub 地址作为数据来源位置之一。用户还可以自定义其他合法选项比如 `"local"` 来指示只考虑本机上的资料夹而非网络链接。 - **trust_repo**: 控制是否允许执行未知第三方提供的脚本逻辑。当设为 `'yes'` 或者显式的真值时表明完全接受外部贡献者的提交记录而无需额外确认安全性方面的问题; 设置成 `'no'` 则拒绝任何未经审核过的改动项. - **force_reload**: 如果设置为 `True` 将忽略缓存副本转而每次都去联网获取最新版档案包即使之前已经存在相同标签号下的快照也会如此操作从而确保获得最前沿的研究成果更新频率较高情况下特别有用处。 - **verbose**: 决定了运行期间是否有详细的进度报告输出到标准错误流上，默认开启有助于调试过程中的跟踪定位工作进展状况。 - **skip_validation**: 当启用该标志位后可以绕开某些内置的安全检查机制以便快速完成初始化阶段但同时也增加了遭遇恶意攻击的风险因此除非必要否则不建议轻易修改此项默认配置状态即保持关闭模式运作更为稳妥可靠些。 --- #### 区别于 `torch.load` 需要注意的是，虽然两者都涉及到了序列化与反序列化进程之中但是它们各自适用场景完全不同 [`torch.load`](https://pytorch.org/docs/stable/generated/torch.load.html)[^2] 主要是用来恢复先前保存下来的张量变量或者是神经网络整体架构连同权重参数一起打包好的二进制格式文件而已并不能单独实现像前者那样便捷地在线抓取开源项目里的现成解决方案提供给我们直接拿来就用的优势所在之处明显有所差异。 另一方面[`torch.hub.load`](https://pytorch.org/docs/stable/hub.html?highlight=torch%20hub%20load#torch.hub.load)[^3] 更侧重于是面向社区共享精神下诞生出来的一种工具集能够让开发者们更加轻松愉快地享受到彼此之间相互协作所带来的便利条件进而推动整个人工智能领域向前发展得更快更好一些！ ---
阅读全文

相关推荐

zip

基于Torch Hub的深度估计模型MiDaS-python源码.zip

在本案例中，MiDaS模型已经被上传到Torch Hub，用户可以直接通过几行代码下载并应用模型，无需理解模型的内部结构或进行复杂的训练过程。 MiDaS模型的设计采用了多尺度深度网络，该网络在不同尺度上处理输入图像，...
pdf

浅谈pytorch torch.backends.cudnn设置作用

综上所述，合理配置torch.backends.cudnn.enabled和torch.backends.cudnn.benchmark对于优化基于PyTorch的深度学习模型的训练性能至关重要。开发者应根据具体的任务需求和输入数据特点来灵活调整这些设置，以...
pdf

python torch.utils.data.DataLoader使用方法

torch.utils.data.DataLoader是PyTorch框架中用于高效加载和处理数据的关键组件。它在机器学习模型的训练过程中起着至关重要的作用，因为它的功能包括数据分批、数据预处理、多线程加载以及可选的随机打乱顺序等。...

torch.hub.load加载pth

上述代码片段展示了如何先通过 torch.hub.load 函数创建一个未初始化权重的模型实例[^4]，随后再用 torch.load 函数读取实际的预训练参数文件[^3]，并将这些参数应用到刚刚创建的模型结构上去。 需要注意的是，...

torch.hub.load加载yolo

### 使用 torch.hub.load 加载 YOLOv5 模型 为了成功加载 YOLOv5 模型，需先确保已安装必要的依赖包： bash pip install tqdm boto3 requests regex sentencepiece sacremoses #### 安装 PyTorch 和 ...

model = torch.hub.load()推理视频

对于使用 torch.hub.load 来加载模型并处理视频数据的任务，可以通过以下方式实现： #### 准备工作 在开始之前，确保已经安装了必要的依赖库。这包括但不限于 PyTorch 及其相关组件。 bash pip install tqdm ...

import cv2 import torch model = torch.hub.load('ultralytics/yolov5', 'custom', path='best.pt') def detect_objects(): cap = cv2.VideoCapture(0) while True: ret, frame = cap.read() results = model(frame) detections = results.pandas().xyxy[0] for _, row in detections.iterrows(): if row['confidence'] > 0.5 and row['name'] in ['red', 'green', 'Tactile_paving']: return row['name']解释代码内容

model = torch.hub.load('ultralytics/yolov5', 'custom', path='best.pt') - 使用torch.hub加载YOLOv5目标检测模型 - custom参数表示加载自定义训练模型 - best.pt是训练好的模型权重文件路径 - 支持检测...

import cv2 import torch # 加载模型 model = torch.hub.load('./base_s16', 'custom' , path='base_s16/weights/best.pt', source='local') # 1.获取视频对象 cap = cv2.VideoCapture('gao.mp4') # 2.判断是否读取成功 while(cap.isOpened()): # 3.获取每一帧图像 ret, frame = cap.read() # 镜像 # frame = cv2.flip(frame, 1) # print(model) # bgr --> rgb img_cvt = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) results = model(img_cvt) # 推理结果 pd = results.pandas().xyxy[0] person_list = pd[pd['name'] == 'person'].to_numpy() print(person_list) helmet_list = pd[pd['name'].str.contains('helmet')].to_numpy() print(helmet_list) # 4.获取成功显示图像 if ret == True: cv2.imshow('frame',frame) # 5.每一帧间隔为25ms break # if cv2.waitKey(25) & 0xFF == ord('q'): # break # 6.释放视频对象 cap.release() cv2.destoryAllwindows()

model = torch.hub.load('./base_s16', 'custom', path='base_s16/weights/best.pt', source='local') # 获取视频对象 cap = cv2.VideoCapture('gao.mp4') # 判断是否读取成功 while cap.isOpened(): # 获取每一...

技术栈：MiDaS + Open3D + Poisson Reconstruction 深度图生成 使用预训练单目深度模型： Python import torch midas = torch.hub.load("intel-isl/MiDaS", "MiDaS_small") depth_map = midas(input_image) # 输入分割后的mask图像 优化策略： 将SAM分割结果作为mask，限制深度估计范围 通过cv2.inpaint()修复mask边缘深度不连续问题 点云生成 使用Open3D构建点云： Python import open3d as o3d point_cloud = o3d.geometry.PointCloud.create_from_depth_image( o3d.geometry.Image(depth_map), intrinsic_matrix, # 需根据原始视频参数估算 depth_scale=1000.0 ) 表面重建 泊松重建（适合有机体形状）： Python mesh, densities = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson( point_cloud, depth=9 # 控制重建细节层级 ) 成功率保障： 对每张图生成的点云进行ICP配准融合 使用mesh.filter_smooth_taubin()平滑表面。我准备复现此方案，我已经得到了由sam分割之后的图片，请给出具体的代码来实现，获得 SAM生成的二值化mask（黑白图），一定要具有可实现性！！

transform = torch.hub.load("intel-isl/MiDaS", "transforms").small_transform input_batch = transform(input_image).to(device) # 推理并后处理 with torch.no_grad(): prediction = midas(input_batch) ...

import cv2 import torch # Load YOLOv5 model (make sure you have the weights file) model = torch.hub.load('ultralytics/yolov5', 'yolov5s') # Open video stream (0 is the default camera) cap = cv2.VideoCapture(0) while True: ret, frame = cap.read() if not ret: break # Get predictions from the model results = model(frame) # Process predictions df = results.pandas().xyxy[0] # get predictions in pandas DataFrame format people_count = df[df['name'] == 'person'].shape[0] # count the number of people # Display people count on frame cv2.putText(frame, f'People Count: {people_count}', (30, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2) # Show the frame with detection cv2.imshow("YOLOv5 Person Detection", frame) # Break the loop if 'q' is pressed if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()

这里使用的是torch.hub.load从ultralytics的仓库加载yolov5s模型。接着，用cv2.VideoCapture(0)打开默认摄像头，进入一个循环读取每一帧。 在循环中，每一帧被送入模型进行检测，结果转换为Pandas DataFrame，筛选...

# -*- coding: gbk -*- import cv2 import torch import numpy as np import os def enhance_depth_estimation(img_path, mask_path): # 加载模型 midas = torch.hub.load("/home/lichuang/project/Opencv-main/sam_yolo/MiDaS/", "DPT_Large", source='local') device = torch.device("cuda" if torch.cuda.is_available() else "cpu") midas.to(device) midas.eval() # 预处理 img = cv2.imread(img_path) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) / 255.0 mask = cv2.imread(mask_path, cv2.IMREAD_GRAYSCALE) # 确保 mask 中的值为 0 和 1，白色部分为 1 mask = (mask > 0).astype(np.uint8) # 应用 mask img_masked = cv2.bitwise_and(img, img, mask=mask) # 转换为模型输入格式，使用图像原始尺寸 input_batch = torch.from_numpy(img_masked).permute(2, 0, 1).unsqueeze(0).float().to(device) # 不再进行插值到 (384, 384) # 深度预测 with torch.no_grad(): prediction = midas(input_batch) prediction = torch.nn.functional.interpolate( prediction.unsqueeze(1), size=img.shape[:2], # 使用图像原始尺寸 mode="bicubic", align_corners=False ).squeeze().cpu().numpy() # 边缘修复 depth_map = (prediction - prediction.min()) / (prediction.max() - prediction.min()) inpainted_depth = cv2.inpaint((depth_map * 255).astype(np.uint8), 255 - mask, 3, cv2.INPAINT_TELEA) return inpainted_depth def process_folders(segmented_folder, mask_folder, output_folder): # 确保输出文件夹存在 os.makedirs(output_folder, exist_ok=True) # 递归遍历分割图文件夹 for root, _, files in os.walk(segmented_folder): for filename in files: if filename.endswith(('.png', '.jpg', '.jpeg')): img_path = os.path.join(root, filename) # 计算相对路径 relative_path = os.path.relpath(root, segmented_folder) mask_path = os.path.join(mask_folder, relative_path, filename) # 检查对应的掩码文件是否存在 if not os.path.exists(mask_path): print(f"未找到对应的掩码文件: {mask_path}，跳过 {img_path}。") continue # 生成深度图 depth_map = enhance_depth_estimation(img_path, mask_path) # 构建输出路径，保持子文件夹结构 output_subfolder = os.path.join(output_folder, relative_path) os.makedirs(output_subfolder, exist_ok=True) output_path = os.path.join(output_subfolder, filename) # 保存深度图 cv2.imwrite(output_path, depth_map) print(f"已为 {img_path} 生成深度图并保存到 {output_path}。") if __name__ == "__main__": segmented_folder = "/home/lichuang/project/Opencv-main/sam_yolo/dataset/input_images/" # 替换为实际的分割图文件夹路径 mask_folder = "/home/lichuang/project/Opencv-main/sam_yolo/dataset/masks/" # 替换为实际的掩码文件夹路径 output_folder = "/home/lichuang/project/Opencv-main/sam_yolo/dataset/depth_maps1/" # 替换为实际的输出深度图文件夹路径 process_folders(segmented_folder, mask_folder, output_folder)修改深度图的生成代码，尝试解决此问题

midas = torch.hub.load("/home/lichuang/project/Opencv-main/sam_yolo/MiDaS/", "DPT_Large", source='local') device = torch.device("cuda" if torch.cuda.is_available() else "cpu") midas.to(device) ...

import os, sys import argparse import torch import numpy as np import math parser = argparse.ArgumentParser(description='LLaMa-2 Self-Attention') parser.add_argument('model_size', type=int, choices = [7, 13], help='The size of the model to use. Default is 13') parser.add_argument('layer', type=int, help='The layer to use for self-attn') parser.add_argument('seq_len', type=int, help='The sequence length to use for self-attn') parser.add_argument('--input_file', required = True, type=str, help='The input file to use for self-attn') parser.add_argument('--output_file', default = 'llama-self-attn-output.bin', type=str, help='The output file to use for self-attn') from transformers import AutoTokenizer, AutoModelForCausalLM from fileio_utils import * VALUE_LOGSF = 16 ACCU_LOGSF = 20 def rotate_half(x): """Rotates half the hidden dims of the input.""" x1 = x[..., : x.shape[-1] // 2] x2 = x[..., x.shape[-1] // 2 :] return torch.cat((-x2, x1), dim=-1) if __name__ == '__main__': compilation_error = os.system('make self-attn') if compilation_error: print("Error compiling self-attn") exit(1) args = parser.parse_args() # model_card = f"meta-llama/Llama-2-{args.model_size}b-hf" model_card = f"model-storage/hub/models--meta-llama--Llama-2-7b-hf/snapshots/01c7f73d771dfac7d292323805ebc428287df4f9" model = AutoModelForCausalLM.from_pretrained(model_card, local_files_only = True, cache_dir = "./model-storage") layer = model.model.layers[args.layer] embed_dim = layer.self_attn.q_proj.in_features workdir = f'./zkllm-workdir/Llama-2-{args.model_size}b' layer_prefix = f'layer-{args.layer}' os.system(f'./self-attn linear {args.input_file} {args.seq_len} {embed_dim} {workdir} {layer_prefix} {args.output_file}') Q, K, V = load_int('temp_Q.bin').reshape(args.seq_len, embed_dim) / (1 << 16), load_int('temp_K.bin').reshape(args.seq_len, embed_dim) / (1 << 16), load_int('temp_V.bin').reshape(args.seq_len, embed_dim) / (1 << 16) Q = Q.view(args.seq_len, layer.self_attn.num_heads, layer.self_attn.head_dim).transpose(0, 1) K = K.view(args.seq_len, layer.self_attn.num_heads, layer.self_attn.head_dim).transpose(0, 1) V = V.view(args.seq_len, layer.self_attn.num_heads, layer.self_attn.head_dim).transpose(0, 1) layer.self_attn.rotary_emb.to(0) cos, sin = layer.self_attn.rotary_emb(torch.randn(1, args.seq_len, embed_dim, device = 0), torch.arange(args.seq_len, device = 0).unsqueeze(0)) Q, K = Q * cos + rotate_half(Q) * sin, K * cos + rotate_half(K) * sin Q, K = Q.to(torch.float64), K.to(torch.float64) A_ = Q @ K.transpose(-2, -1) A = to_int64(A_, VALUE_LOGSF) # an upper triangular mask for perplexity mask = torch.triu(torch.ones(args.seq_len, args.seq_len, device = 0, dtype = bool), diagonal = 1) A -= torch.max(A * ~mask, dim = -1, keepdim = True).values shift = math.sqrt(layer.self_attn.head_dim) * torch.log((torch.exp((to_float(A, ACCU_LOGSF) / math.sqrt(layer.self_attn.head_dim))) * ~mask).sum(axis = -1, keepdim = True)) shift = to_int64(shift, ACCU_LOGSF) A -= shift attn_output = (torch.exp(to_float(A, ACCU_LOGSF, torch.float64) / math.sqrt(layer.self_attn.head_dim)).float()) * ~mask attn_output = attn_output @ V attn_output = fromto_int64(attn_output, VALUE_LOGSF) attn_output = attn_output.transpose(0, 1).contiguous() attn_output = attn_output.view(args.seq_len, embed_dim) attn_output = attn_output.transpose(0, 1).reshape(args.seq_len, embed_dim) save_int(attn_output, 1 << 16, 'temp_attn_out.bin') os.system(f'./self-attn attn {args.input_file} {args.seq_len} {embed_dim} {workdir} {layer_prefix} {args.output_file}') os.system('rm ./temp*.bin')解释代码含义，解释中要对用到的函数做简要解释，我是个小白，有些函数不理解什么意思

然后加载模型，使用Hugging Face的from_pretrained方法，这里用户可能对本地模型路径和cache_dir有疑问，需要解释模型是如何存储和加载的。接着，代码获取指定层的自注意力模块，并提取embed_dim，这部分需要说明...

import cv2 import torch import numpy as np from pathlib import Path from models.fgd_net import FGDNet # 确保模型定义可访问 class SimpleDeploy: def __init__(self, weight_path="weights/best_model.pth"): self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu") self.model = FGDNet().to(self.device) self.model.load_state_dict(torch.load(weight_path, map_location=self.device)) self.model.eval() # 切换到推理模式 @staticmethod def preprocess(img_path, target_size=(1024, 1024)): """ 图像预处理：灰度化 -> 归一化 -> 张量转换 """ img = cv2.imread(str(img_path), cv2.IMREAD_GRAYSCALE) img = cv2.resize(img, target_size) # 确保与训练尺寸一致 tensor = torch.from_numpy(img.astype(np.float32) / 255.0) return tensor.unsqueeze(0).unsqueeze(0) # (1,1,H,W) def process_pair(self, ir_path, fused_path, output_dir="output"): """ 处理单对图像 """ # 加载数据 ir_tensor = self.preprocess(ir_path).to(self.device) fused_tensor = self.preprocess(fused_path).to(self.device) # 生成引导特征 with torch.no_grad(): guide_feat = self.model.enc2(self.model.enc1(fused_tensor)) # 执行推理 output = self.model(ir_tensor, guide_feat) # 后处理与保存 output_np = output.squeeze().detach().cpu().numpy() * 255 output_np = np.clip(output_np, 0, 255).astype(np.uint8) # 确保像素值在 [0, 255] 范围内 output_dir = Path(output_dir) output_dir.mkdir(parents=True, exist_ok=True) # 确保输出目录存在 output_path = output_dir / f"result_{Path(ir_path).name}" try: cv2.imwrite(str(output_path), output_np) print(f"处理完成 ➜ {output_path}") except Exception as e: print(f"写入图像时出错: {e}") if __name__ == "__main__": deploy = SimpleDeploy() # 自动处理input目录下所有匹配文件 input_dir = Path("input") for ir_file in input_dir.glob("ir_*.jpg"): fused_file = input_dir / f"fused_{ir_file.stem.split('_')[-1]}.jpg" if

model = torch.hub.load('ultralytics/yolov5', 'custom', path='runs/detect/train/weights/best.pt') # 配置输入数据路径和输出保存路径 input_dir = 'substation_ir_dataset/images/test/' # 输入图像所在目录 ...

Traceback (most recent call last): File "E:\Anaconda3\CNN\t-sne_CNN.py", line 22, in <module> model = torch.load('./save_fig_model/model/CNN_CWRU20(10).pt')

此外，如果模型是通过torch.hub.load从网上加载的，可能需要检查源是否正确，如引用[1]中的参数source是否为github或本地，是否有权限问题，或者是否强制重新下载（force_reload）。 还有文件损坏的可能性，用户...

import cv2 import torch import numpy as np class MonoDistance: def __init__(self, cam_matrix, person_height=1.7): self.cam_matrix = cam_matrix self.ref_height = person_height def estimate(self, bbox): pixel_height = bbox[3] - bbox[1] return (self.ref_height * self.cam_matrix[1,1]) / pixel_height def main(): # 加载模型 model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True) # 相机参数 cam_matrix = np.array([[900, 0, 640], [0, 900, 360], [0, 0, 1]]) distance_estimator = MonoDistance(cam_matrix) cap = cv2.VideoCapture(0) cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720) while True: ret, frame = cap.read() if not ret: break # 推理 results = model(frame) detections = results.pandas().xyxy[0] # 处理行人检测 for _, row in detections[detections['name'] == 'person'].iterrows(): x1, y1, x2, y2 = map(int, row[['xmin','ymin','xmax','ymax']]) distance = distance_estimator.estimate((x1,y1,x2,y2)) cv2.rectangle(frame, (x1,y1), (x2,y2), (0,255,0), 2) cv2.putText(frame, f"{distance:.2f}m", (x1,y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0,255,255), 2) cv2.imshow('Demo', frame) if cv2.waitKey(1) == ord('q'): break cap.release() cv2.destroyAllWindows() if __name__ == "__main__": main() import cv2 import torch import numpy as np class MonoDistance: def __init__(self, cam_matrix, dist_coeffs, person_height=1.7): self.cam_matrix = cam_matrix # 相机内参矩阵 self.dist_coeffs = dist_coeffs # 畸变系数 self.ref_height = person_height # 行人平均身高 def estimate(self, bbox): # 基于目标高度测距 y2 = bbox[3] y1 = bbox[1] pixel_height = abs(y2 - y1) return (self.ref_height * self.cam_matrix[1, 1]) / pixel_height def main(): # 加载改进模型 model = torch.hub.load('ultralytics/yolov5', 'custom', path='weights/best.pt') # 相机标定参数 cam_matrix = np.array([[900, 0, 640], [0, 900, 360], [0, 0, 1]]) dist_coeffs = np.array([-0.12, 0.25, 0, 0]) # 初始化测距模块 distance_estimator = MonoDistance(cam_matrix, dist_coeffs) # 摄像头初始化 cap = cv2.VideoCapture(0) cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720) while True: ret, frame = cap.read() if not ret: break # YOLOv5检测 results = model(frame) detections = results.pandas().xyxy[0] # 处理每个检测目标 for _, row in detections[detections['name'] == 'person'].iterrows(): x1, y1, x2, y2 = map(int, row[['xmin', 'ymin', 'xmax', 'ymax']]) # 测距计算 distance = distance_estimator.estimate((x1, y1, x2, y2)) # 绘制结果 cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2) cv2.putText(frame, f"{distance:.2f}m", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2) # 显示帧率 cv2.putText(frame, f"FPS: {model.fps:.1f}", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2) cv2.imshow('Pedestrian Detection', frame) if cv2.waitKey(1) == ord('q'): break cap.release() cv2.destroyAllWindows() if __name__ == "__main__": main()修改上述代码，并详细指导用户如何把代码中yolov5模型，换成用户本地部署好的yolov5模型

首先，用户当前的代码中使用的是torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)来加载模型，这是从官方仓库直接下载预训练的模型。而用户想要替换成本地训练好的模型，通常本地模型是保存为....

解读import torch.nn as nn from huggingface_hub import PyTorchModelHubMixin def wrap_model_hub(model_cls: nn.Module): class HfModel(model_cls, PyTorchModelHubMixin): def __init__(self, config: dict): super().__init__(**config) self.config = config return HfModel

- from_pretrained：读取配置实例化模型，再加载权重。 #### 三、应用场景 - **多分支模型**：如残差网络（需自定义前向逻辑）。 - **自定义层**：例如实现特殊初始化或动态计算图。 - **模型共享**：将私有模型...

# 导入所需库 import cv2 # OpenCV用于图像处理 import torch # PyTorch框架 import numpy as np # 数值计算库 # 加载预训练的YOLOv5模型 model = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True) # 加载YOLOv5s模型 # 初始化摄像头 cap = cv2.VideoCapture(0) # 0表示默认摄像头 # 相机参数设置） FOCAL_LENGTH = 720 # 焦距（单位：像素），需通过相机标定获得 REAL_HEIGHT = 1.7 # 行人平均实际高度（单位：米） def calculate_distance(box_height): """计算目标距离（单目测距）""" # 距离公式：距离 = (实际高度 * 焦距) / 检测框高度 return (REAL_HEIGHT * FOCAL_LENGTH) / box_height if box_height != 0 else 0 while True: # 读取摄像头帧 ret, frame = cap.read() if not ret: break # 执行目标检测 results = model(frame) # 解析检测结果 detections = results.pandas().xyxy[0] # # 遍历每个检测目标 for _, det in detections.iterrows(): if det['name'] == 'person' and det['confidence'] > 0.5: # 过滤行人且置信度>50% x1, y1, x2, y2 = int(det['xmin']), int(det['ymin']), int(det['xmax']), int(det['ymax']) # 计算边界框高度 box_height = y2 - y1 # 计算距离 distance = calculate_distance(box_height) # 绘制边界框和距离信息 cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2) # 绘制绿色矩形框 cv2.putText(frame, f"{distance:.2f}m", (x1, y1 - 10), # 显示距离 cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2) # 显示处理结果 cv2.imshow('Pedestrian Detection', frame) # 退出条件（按Q键退出） if cv2.waitKey(1) & 0xFF == ord('q'): break # 释放资源 cap.release() # 释放摄像头 cv2.destroyAllWindows() # 关闭所有OpenCV窗口 如何把上述代码中的yolov5模型，换成本地修改过后的yolov5模型，同时优化上述代码

model = torch.hub.load('path/to/local/yolov5', 'custom', path='custom_yolov5.pt', source='local') # 视频处理管道 with video_capture(0) as cap: while True: ret, frame = cap.read() if not ret: ...

Traceback (most recent call last): File "/root/siton-tmp/MedCLIP-SAMv2/segment-anything/prompt_sam.py", line 347, in <module> main(args) File "/root/siton-tmp/MedCLIP-SAMv2/segment-anything/prompt_sam.py", line 294, in main sam = sam_model_registry[args.model_type](checkpoint=args.checkpoint) File "/root/siton-tmp/MedCLIP-SAMv2/segment-anything/segment_anything/build_sam.py", line 15, in build_sam_vit_h return _build_sam( File "/root/siton-tmp/MedCLIP-SAMv2/segment-anything/segment_anything/build_sam.py", line 105, in _build_sam state_dict = torch.load(f, weights_only=True) File "/opt/conda/envs/medclipsamv2/lib/python3.9/site-packages/torch/serialization.py", line 1432, in load with _open_zipfile_reader(opened_file) as opened_zipfile: File "/opt/conda/envs/medclipsamv2/lib/python3.9/site-packages/torch/serialization.py", line 763, in __init__ super().__init__(torch._C.PyTorchFileReader(name_or_buffer)) RuntimeError: PytorchStreamReader failed reading zip archive: failed finding central directory

根据引用[3]，模型通常存放在用户目录下的.cache/torch/hub/checkpoints里，比如C:\Users\用户名\.cache\torch\hub\checkpoints，删除对应的模型文件，再重新运行代码，让程序重新下载。 还有可能模型文件路径不对...

大家在看

recommend-type

matlab开发-高斯系数模型中DoLoanPortfolio的累积分布函数

matlab开发-高斯系数模型中DoLoanPortfolio的累积分布函数。用高斯因子模型计算CDO贷款组合损失的累积分布函数
recommend-type

Delphi编写的SQL查询分析器.rar

因为需要在客户那里维护一些数据, 但是人家的电脑不见得都安装了SQL Server客户端, 每次带光盘去给人家装程序也不好意思. 于是就写这个SQL查询分析器。代码不够艺术, 结构也松散, 如果代码看不懂, 只好见谅了. 程序中用到的图标, 动画都是从微软的SQLServer搞过来的, 唯一值得一提的是, 我用了ADO Binding for VC Extension(MSDN上有详细资料), 速度比用Variant快(在ADOBinding.pas和RowData.pas)。
recommend-type

华为代码统计工具CCT V2.0

代码规模统计工具CCT是根据华为公司的项目特点而开发的软件规模统计工具；它既可以统计指定版本的非空非注释（NBNC）行，也可以通过比较当前版本和基础版本，计算新增修改规模得到增强项目的规模。&lt;br&gt;&lt;br&gt;CCT通过辨认不同的扩展名支持对多种语言的规模统计，包括C,C++,JAVA,DELPHI,汇编(ASM),SQL,JSP,ASP,HTML和TXT等文件。
recommend-type

现代密码学的答案习题

偏向于电子科大方面的教学，较为基础的信息概述和练习
recommend-type

yitaiwang.rar_4341_ARM ethernet_lpc2468_smartarm2400_以太网

LPC2468开发板光盘 SmartARM2400开发平台配套例程 ARM嵌入式系统应用技术笔记_下册例程 以太网

最新推荐

recommend-type

C++经典扫雷开发项目和安装包

这是一款用 C++ 开发的经典扫雷项目，适合 C++ 爱好者与初学者。资源包内有详尽代码注解、完整源码及 12 种游戏必备图像素材，覆盖雷区标志等。教程从设计原理讲起，细到代码结构、实战部署，涉及初始化地图、随机布雷、统计邻近雷数、图像加载、事件处理与胜负判定等。开发环境建议用 Visual Studio ，需安装 EasyX 图形库，项目配置为多字节字符集。
recommend-type

C#实现多功能画图板功能详解

根据给定的文件信息，我们可以从中提取出与C#编程语言相关的知识点，以及利用GDI+进行绘图的基本概念。由于文件信息较为简短，以下内容会结合这些信息点和相关的IT知识进行扩展，以满足字数要求。 标题中提到的“C#编的画图版”意味着这是一款用C#语言编写的画图软件。C#（发音为 "C Sharp"）是一种由微软开发的面向对象的高级编程语言，它是.NET框架的一部分。C#语言因为其简洁的语法和强大的功能被广泛应用于各种软件开发领域，包括桌面应用程序、网络应用程序以及游戏开发等。 描述中提到了“用GDI+绘图来实现画图功能”，这表明该软件利用了GDI+（Graphics Device Interface Plus）技术进行图形绘制。GDI+是Windows平台下的一个图形设备接口，用于处理图形、图像以及文本。它提供了一系列用于2D矢量图形、位图图像、文本和输出设备的API，允许开发者在Windows应用程序中实现复杂的图形界面和视觉效果。 接下来，我们可以进一步展开GDI+中一些关键的编程概念和组件： 1. GDI+对象模型：GDI+使用了一套面向对象的模型来管理图形元素。其中包括Device Context（设备上下文）, Pen（画笔）, Brush（画刷）, Font（字体）等对象。程序员可以通过这些对象来定义图形的外观和行为。 2. Graphics类：这是GDI+中最核心的类之一，它提供了大量的方法来进行绘制操作，比如绘制直线、矩形、椭圆、曲线、图像等。Graphics类通常会与设备上下文相关联，为开发人员提供了一个在窗口、图片或其他表面进行绘图的画布。 3. Pen类：用于定义线条的颜色、宽度和样式。通过Pens类，GDI+提供了预定义的笔刷对象，如黑色笔、红色笔等。程序员也可以创建自定义的Pen对象来满足特定的绘图需求。 4. Brush类：提供了用于填充图形对象的颜色或图案的对象，包括SolidBrush（实心画刷）、HatchBrush（图案画刷）、TextureBrush（纹理画刷）等。程序员可以通过这些画刷在图形对象内部或边缘上进行填充。 5. Fonts类：表示字体样式，GDI+中可以使用Fonts类定义文本的显示样式，包括字体的家族、大小、样式和颜色。 6. 事件驱动的绘图：在C#中，通常会结合事件处理机制来响应用户操作（如鼠标点击或移动），以实现交互式的绘图功能。程序员可以通过重写控件的事件处理函数（例如MouseClick, MouseMove等）来捕获用户的输入并作出相应的绘图响应。 7. 画布变换：在GDI+中，可以通过变换Graphics对象来实现平移、旋转和缩放等效果，这对于实现更复杂的绘图功能是非常有用的。 由于没有具体的文件名称列表，我们无法从这方面提取更多的知识点。但根据标题和描述，我们可以推断该文件名称列表中的“画图板”指的是这款软件的名称，这可能是一个与GDI+绘图功能相结合的用户界面程序，它允许用户在界面上进行绘画和书写操作。 总结以上内容，我们可以了解到C#编程语言与GDI+结合可以创建出功能丰富的画图应用程序。开发人员能够利用GDI+提供的丰富API实现复杂的图形操作，提供用户友好的界面和交互体验。这不仅有助于提高软件的图形处理能力，同时也能够满足设计人员对于高质量视觉效果的追求。
recommend-type

超参数调优：锂电池预测模型优化的不传之秘

# 摘要 本文针对锂电池预测模型的优化进行了系统性的研究，深入探讨了理论基础、超参数调优的策略与技巧，并实践了在锂电池预测模型中的应用。通过理论分析与实验验证，本文揭示了超参数与模型性能之间的关系，并探讨了多种超参数优化方法。同时，本文提供了针对锂电池预测模型的性能评估方法，识别并解决了过拟合与
recommend-type

青龙面板怎么搭建

<think>我们正在回答用户关于如何在服务器上搭建青龙面板的问题。根据用户提供的引用，我们有多个不同的安装方法，主要使用Docker进行部署。我们将综合这些引用，给出一个清晰、步骤详细的安装教程。 注意：青龙面板是一个支持Python3、JavaScript、Shell、TypeScript的定时任务管理平台，常用于运行各种脚本。 我们将按照以下步骤进行： 1. 准备环境：确保服务器已安装Docker和Docker Compose。 2. 创建目录并下载配置文件（如果使用docker-compose方式）。 3. 运行容器。 4. 访问面板并进行初始化配置。 由于引用中有
recommend-type

全面深入掌握应用密码学第二版精华

### 知识点概述 **标题**：Applied Cryptography PART1 **描述**：《应用密码学第二版》是一本全面的密码学资料，它涵盖密码学的基础知识和高级应用，对于想要深入理解并运用密码学的读者来说，是一个宝贵的资源。 **标签**：Applied Cryptography 密码 应用 **压缩包子文件列表**：APPLYC12.pdf、APPLYC11.pdf、APPLYC3.pdf、APPLYC4.pdf、APPLYC2.pdf、APPLYC5.pdf、APPLYC13.pdf、APPLYC6.pdf、APPLYC14.pdf、APPLYC9.pdf ### 知识点详细说明 #### 密码学基础 密码学（Cryptography）是研究信息加密和解密的数学原理和计算方法的学科。在《应用密码学第二版》中，可能涉及以下基础知识： 1. **对称密钥加密**：使用相同的密钥进行加密和解密，如AES（高级加密标准）和DES（数据加密标准）算法。 2. **非对称密钥加密**：使用一对密钥（公钥和私钥），公钥加密信息，私钥解密，如RSA算法。 3. **哈希函数**：一种单向加密函数，将任意长度的数据映射到固定长度的值，如SHA-256和MD5。 4. **数字签名**：利用非对称密钥加密原理，用于验证消息的完整性和来源。 #### 密码学的应用 **应用密码学**涉及到将密码学原理和技术应用到实际的安全问题和解决方案中。在该书籍中，可能会探讨以下应用领域： 1. **网络安全**：包括SSL/TLS协议，用于保护互联网上的通信安全。 2. **区块链技术**：密码学在区块链中的应用，如工作量证明（Proof of Work）和非对称密钥。 3. **安全存储**：如何使用加密技术安全地存储数据，例如在数据库中的加密技术。 4. **安全协议**：在不同计算平台间交换加密信息的协议，例如IPSec。 #### 密码学进阶主题 进阶主题可能包括： 1. **密码学中的数学基础**：素数、群、环、域以及椭圆曲线等数学概念。 2. **密码分析**：研究攻击加密系统的方法，包括已知明文攻击、选择明文攻击等。 3. **量子密码学**：探讨量子计算对当前加密算法的影响，以及量子安全的加密技术。 #### 文档内容细节 从压缩包子文件列表来看，文档内容可能按照章节或主题进行分割，例如： - **APPLYC12.pdf** 和 **APPLYC11.pdf** 可能涵盖了密码学的基础知识和基本概念。 - **APPLYC3.pdf** 和 **APPLYC4.pdf** 可能讨论了对称加密算法以及实现的案例和方法。 - **APPLYC2.pdf** 和 **APPLYC5.pdf** 可能深入讲解了非对称加密技术，如RSA算法。 - **APPLYC13.pdf** 和 **APPLYC6.pdf** 可能包含了哈希函数和数字签名的详细描述。 - **APPLYC14.pdf** 和 **APPLYC9.pdf** 可能介绍了密码学在网络安全、区块链、安全存储和安全协议中的应用实例。 ### 结论 《应用密码学第二版》作为一本全面的密码学参考书，不仅为读者提供了密码学的基础理论知识，还深入探讨了这些理论在现实世界中的具体应用。通过阅读这本书籍，读者将能够更好地理解密码学的原理，并学会如何在实际中运用这些知识来解决安全问题。特别是对于那些希望在信息安全领域深造的学习者来说，该书无疑是一份宝贵的资源。通过对压缩包子文件列表的分析，我们可以看到这本书覆盖了广泛的加密算法和技术，使其成为密码学爱好者的必读之作。
recommend-type

LSTM网络结构选择指南：让锂电池寿命预测更准确

# 摘要 长短期记忆网络（LSTM）作为一种特殊的循环神经网络（RNN），近年来因其在序列数据处理上的卓越性能受到广泛关注。本文首先介绍了LSTM网络的基础知识及在锂电池寿命预测中的应用概述。随后深入探讨了LSTM的理论框架、关键技术、网络结构选择与优化。文中详细分析了锂电池寿命预测的数据处理流程、模型
recommend-type

大物公式

<think>首先，用户意图是查找大学物理相关公式，用户问题是“大学物理常用公式汇总”。我需要根据任务要求进行网络搜索，整合内容，生成回答。 任务要求关键点： - 调用网络搜索工具进行检索。 - 整合内容，生成详细、清晰、实用、可操作的回答。 - 禁止将所有引用内容集中在回答末尾；引用应该分散在回答中。 - 避免使用第一人称（如“我”）。 - 避免步骤词汇（如“首先”、“然后”）。 - 组织答案为多个方法或步骤，每个步骤间换行。 - 对于公式和代码：行内公式用$ $，独立公式用$$ $$；代码用三个反引号注明语言。 - 回答后添加“§§相关问题§§:”部分，列出至少3个相关问题，基于用户问题
recommend-type

全面掌握西门子PLC技术的中文培训资料

西门子是全球知名的电气工程和电子公司，以生产自动化设备、驱动和控制技术等工业产品而著称。在自动化领域，西门子的可编程逻辑控制器（PLC）尤为著名，是工业自动化系统中的核心设备之一。以下是从提供的文件信息中提炼出的知识点。 1. 西门子PLC技术介绍 - 西门子PLC是指西门子生产的一系列可编程逻辑控制器，包括S7-1200、S7-1500等型号，广泛应用于各种自动化生产、加工和监测系统。 - PLC技术是工业自动化领域的核心技术之一，用于替代传统的继电器逻辑控制，通过软件编程实现对工业过程的控制。 - PLC具备高可靠性、高稳定性和灵活的可扩展性，适合各种复杂控制任务。 2. 西门子PLC编程基础 - 西门子PLC编程通常采用STEP 7、TIA Portal等专业软件，支持梯形图、功能块图、语句列表等多种编程语言。 - 用户需要掌握基本的PLC硬件知识，例如CPU、数字/模拟输入输出模块、通讯模块等的配置和使用方法。 - 理解基本的编程概念，如I/O映射、变量存储、数据类型以及模块化编程等。 3. 西门子PLC的网络通讯 - 熟悉西门子PLC的网络通讯协议，如PROFINET、Profibus等，以及如何在不同设备间实现数据交换和设备互联。 - 网络通讯是实现工业4.0和智能制造的关键技术，对于实现远程监控和数据采集（SCADA）系统非常重要。 - 学习如何配置网络参数、故障诊断和维护通讯系统。 4. 西门子PLC的高级应用 - 进阶知识包括PID控制、运动控制、数据记录和故障诊断等高级功能。 - 掌握如何应用西门子PLC在特定工业场景中的高级控制策略，比如在纺织、包装、汽车制造等行业。 - 学习如何使用HMI（人机界面）与PLC交互，设计直观的操作界面，提高操作便利性和效率。 5. 西门子PLC的维护与故障排除 - 了解如何对西门子PLC进行日常检查和维护工作，以确保系统稳定运行。 - 学习如何使用诊断工具，对PLC及其外围设备进行故障检测和快速修复。 6. 西门子PLC培训的资源与支持 - 利用西门子官方提供的培训材料和在线资源，比如培训手册、视频教程、FAQ等。 - 参与西门子或授权的第三方培训机构组织的培训课程，以获取更加系统和深入的知识。 - 加入西门子技术支持社区和论坛，与其他工程师交流心得，解决遇到的技术难题。 综上所述，西门子中文培训资料内容涵盖了从基础理论到高级应用、从硬件操作到软件编程、从系统配置到故障排除的全方位知识。这些资料不仅适合自动化领域的初学者，也为经验丰富的工程师提供了复习和拓展知识的途径。学习西门子PLC技术能够提高个人的市场竞争力，同时也为推动工业自动化和智能制造的发展做出贡献。
recommend-type

揭秘LSTM预测锂电池RUL：一步到位的实现秘籍

# 摘要 本文综合论述了使用长短期记忆网络（LSTM）对锂电池剩余使用寿命（RUL）进行预测的理论和实践方法。首先介绍了锂电池衰退的基本理论和衰退机制，然后深入探讨了LSTM的网络结构及在RUL预测中的应用，包括数据预处理、模型设计、评估与优化。实战演练部分详细描述了数据集的准备、模型编码实现和预测结果的解读。最后，本文展望了LSTM在该领域的未来发展方
recommend-type

True Traceback (most recent call last): File "/home/xxzx/Desktop/ruanzhu/ziti.py", line 9, in <module> print(fm.get_cachedir()) # 显示缓存路径 ^^^^^^^^^^^^^^^ AttributeError: module 'matplotlib.font_manager' has no attribute 'get_cachedir'

<think>我们遇到了一个具体问题：用户在使用`matplotlib.font_manager.get_cachedir`时遇到了`AttributeError`，因为该方法不存在。我们需要提供替代方法或解决方案。 在Matplotlib中，获取字体缓存目录的正确方法是什么？ 根据Matplotlib文档和常见实践，我们可以使用以下方法： 1. 使用`matplotlib.get_cachedir()`函数（从matplotlib 1.2开始提供）[^1]。 2. 使用`matplotlib.font_manager.get_font_cache_path()`（在较新版本中）[