【开源资料】XQTyer评估板例程使用手册.pdf链接：https://share.weiyun.com/8csewUvh 密码：8r9by7CSDN搜索【DSP+ZYNQ多核例程使用手册-XQTyer】XQ6657Z35/45-EVM 高速数据处理评估板（XQTyer 评估板）由广州星嵌电子科技有限公司自主研发，包含一片TI DSP TMS320C6657和一片Xilinx ZYNQ-7000 SoC 处理器XC7Z035-2FFG676I。适用于无人机蜂群、软件无线电系统，基带信号处理，无线仿真平台，高速图像采集、处理等领域。

当触发一定条件时，摄像头瞄准指定位置，一分钟后恢复原始位置，随后继续监测是否达到条件。如此执行一至两天后（有时更短），指定位置的PTZ坐标发生了变化，即预先设定好的PTZ坐标不是我所需要的位置。这种情况有遇到过嘛……可能是哪些原因造成的。我已经排除了摄像头本身被转动的可能。

【特性介绍】企业支持管理员、部门管理员、普通用户三种角色支持管理员对角色进行调整【适用平台】      IVM Portal √好望云企业APP √好望云个人APP ×      北向接口API√【IVM-操作视频】video【IVM-操作步骤】1、企业管理员切换至普通用户，当企业管理员所属部门为企业根目录，将无法设置为部门管理员。单击“编辑”打开“编辑用户”对话框，该用户所属部门为企业根目录，所以只能在企业管理员与普通用户来回切换2、企业管理员切换为部门管理员。选择企业下的部门，选择需要切换角色的用户打开“编辑用户”对话框，三个角色均可来回切换

【适用平台】IVM Portal √好望云企业APP ×好望云个人APP ×北向接口API ×【IVM-操作视频】video【IVM-操作步骤】进入IVM portal页面，选择设备，进入设备管理列表，单击下列导出图标即可，会自动下载到本地以下为导出示例

   对应的视频教程，可参考：【使用MindStudio进行基于双目视觉的目标定位】一、基于双目视觉的目标定位介绍基于计算机视觉的目标定位有单目视觉和双目视觉两种定位方式。单目视觉使用一台相机获取场景图像。由于图像透视投影过程丢失深度信息，因此单目视觉深度恢复得到物体的相对位置。双目视觉感知原理基于哺乳动物视觉机制，获取物体在左右两个相机的图像，并从获取图像恢复物体的三维几何信息。双目视觉从场景获取一组图像，利用这组图像标定相机参数，恢复物体三维几何信息。双目视觉的通用流程是特征点提取、特征点匹配、相机标定、三维重建等处理过程，恢复场景物体的三维几何信息，实现从二维图像重建三维场景。本案例输入的是用自制双目相机同时获取场景物体的图像，案例介绍利用MindX SDK对两幅图像进行相机标定、图像畸变矫正、视差求解、用MindX SDK模型检测目标、计算相物体的三维坐标。项目所用硬件平台：Ascend 310服务器，Atlas 200DK板卡，支持的SDK版本为mxVision 3.0.RC3。双目视觉目标定位流程，如图1-1所示。图1-1 双目视觉目标定位流程双目视觉目标定位流程主要步骤如下：（1）输入一组图像数据标定相机参数，标定的参数包括内参和外参。（2）利用标定的相机参数，用OpenCV函数stereoRectify和remap进行图像校正处理。（3）调用OpenCV函数StereoSGBM_create计算两张图像的视差。（4）通过调用MindX SDK 提供的图像处理插件ImageProcessor的成员函数decode解码并获取校正后图像。（5）对图像进行尺寸变换，调用MindX SDK提供的图像处理插件ImageProcessor的图像尺寸大小改变函数resize改变图像尺寸。（6）调用MindX SDK的Model的infer函数，调用YoloV3模型对尺寸变换后的图像进行推理，定位出目标物体。（7）模型后处理，调用MindX SDK函数post.Yolov3PostProces得到模型推理结果。（8）使用 BTensor函数对后处理结果进行处理，得到标注检测到物体包围盒的左上角和右下角坐标。（9）取右下角坐标，用项目方法把物体检测结果转化为三维坐标。二、MindStudio介绍与安装2.1 MindStudio简介      MindStudio是华为自研昇腾AI处理器开发的AI全栈开发工具平台，该IDE(Integrated Development Environment，集成开发环境)上功能很多，可以进行包括网络模型训练、移植、应用开发、推理运行及自定义算子开发等多类型任务。MindStudio具有工程项目管理、编译、调试、运行等常用功能，还具有性能分析、算子比对等功能，可有效提高开发人员的工作效率。此外，MindStudio具有远程操控功能，可执行远端任务。       MindStudio提供AI开发所需的一站式开发环境，支持模型开发、算子开发以及应用开发三个主流程的开发任务。通过模型可视化、算力测试、IDE本地仿真调试等功能，MindStudio能够在一个IDE中高效便捷地完成AI应用开发。MindStudio采用插件扩展机制，开发者可以通过开发插件来扩展已有功能。2.2 MindStudio安装MindStudio下载地址为MindStudio下载-昇腾社区。点击MindStudio_{version}_win.exe后的“软件包下载”，将其下载到本地指定的目录。双击该软件包，即可开始安装MindStudio。MindStudio安装具体步骤包括 。进入MindStudio Setup安装界面，如图2-1所示，单击“Next”。图2-1 MindStudio 安装开始界面2. 非首次安装MindStudio时，可选择是否卸载已安装MindStudio版本。若不卸载已有版本，直接点击“Next”，进入步骤4；若要卸载则勾选相应版本，点击“Next”，进入步骤3，若同时勾选静默卸载，则会保留之前安装的MindStudio版本的一些配置。图2-2 卸载之前安装的MindStudio版本选取3. 选择需要卸载的项，单击“Uninstall”进行卸载。图2-3 卸载MindStudio4. 输入或选择MindStudio的安装路径，单击“Next”进入下一步骤。图2-4 输入或选取确定MindStudio安装路径5. 根据需要勾选安装选项，选项给出是/否在桌面产生MindStudio快捷启动、是/否把MindStudio可执行文件目录加入到系统路径变量PATH、是/否在右键弹出Context菜单出现“Open Folder as Project”选项、MindStudio缺省关联的文件扩展名，图2-5给出.java、.groovy、.kt及.kts扩展名文件。点击“Next”进入下一步骤。图2-5 选取设定安装配置选项       6. 选择或创建MindStudio安装路径下的启动菜单文件夹，默认即可，单击“Install”。图2-6 Start Menu Folder7. 开始安装MindStudio，完成后单击“Next”。8. 安装完成后，单击“Finish”。9. 双击桌面的MindStudio图标启动MindStudio，或者进入MindStudio安装目录的bin文件夹，双击MindStudio应用程序启动MindStudio。进入设置界面，如图2-7所示。图2-7 首次启动环境设置       默认选择“Do not import settings”，即不导入设置。选择该选项会创建新的配置文件。10. 如果没有报错信息则进入欢迎界面，表示MindStudio安装成功，如图2-8所示。图2-8 MindStudio启动初始界面2.3安装项目运行依赖环境2.3.1安装Python1. 进入Python官网，点击Downloads选项，选择下载Python版本。MindStudio目前支持的Python版本为3.7~3.9。2. 将下载Python压缩包解压、运行，进入图2-9所示的安装选项选取界面。3. 此页面中的选项全部勾选即可，然后点击“Next”。图2-9 安装选项设定4. 在Advanced Options 窗口中，点击“Customize install location”更改安装路径；选取“Create shortcuts for installed applications”在桌面创建Python启动快捷图标；选取“Add Python to environment variables”把Python安装目录加入到系统环境变量。点击“Install”进入安装。图2-10 设定Python安装选项5. 安装完成后，打开Command命令提示符窗口，输入“python”，显示如图2-11所示Python版本信息，表明Python成功安装。图2-11 检查python是否成功安装6. 在MindStudio中配置Python解释器(1) 在菜单栏中选择 File → Project Structure，在 Project Structure窗口中，点击 Platform Settings → SDKs，点击上方的“+”添加 Python SDK，如图2-12。图2-12 添加 Python SDK目录       在弹出窗口中选取“Existing environment”，选择python.exe的安装目录，点击“OK”完成在MindStudio配置Python解释器。若选取“New environment”，则会将“Base interpreter”的python 环境复制到工程目录下，该选项设置表示项目所有类库依赖都脱离系统安装python而运行。图2-13 设置Python解释器目录(2) 在Project Structure窗口中点击 Project Settings → Project，选择添加的 Python SDK，如图2-14所示。图2-14 选择Python SDK(3) 在Project Structure窗口中点击 Project Settings → Modules，右键工程名称，选择“Add”菜单项的“Python”，为 Python Interpreter 添加 Python SDK。点击“Apply”后再点击“OK”，如图2-15所示。图2-15 设定 Python解释器       Python SDK已配置完成。注意：上面各项配置好后，先点击“Apply”后再点击“OK”。2.3.2安装MinGW       MinGW下载地址：cid:link_7       选择下图中红框内的版本进行下载。图2-16 MinGW版本选择       下载后直接将其解压至自定义目录。把MinGW的bin文件路径添加到环境变量中，则安装完成。打开Command命令提示符窗口，输入“g++ --version”，显示如图2-17所示信息，则表示安装成功。图2-17 检查MinGW是否成功安装2.3.3安装CMake       CMake下载地址：https://cmake.org/download/       下载图2-18红框所示版本。图2-18 CMake版本选择       下载完成后，双击安装包进入安装。安装时选择“Add CMake to the system PATH for all users”把CMake路径加入到环境变量。安装完成后打开CMD命令提示符窗口，输入“cmake –version”，若显示如图2-19所示窗口，表明CMake安装成功。图2-19 检查CMake是否成功安装2.3.4安装CANN工具包       从菜单栏中点击File → Settings，并在弹出的窗口中选择Appearance & Behavior → System Settings → CANN进入CANN管理界面，如图2-20所示。图2-20 CANN管理界面       上图所示为CANN工具包安装完成界面。CANN工具包未安装时，蓝框中内容为空，点击图中的Change CANN，进入图2-21所示界面。图2-21 CANN安装       单击“Remote Connection”后的“+”号， 配置MindStudio连接远程开发环境Ascend-cann-toolkit开发套件包；单击“Remote CANN location”后的文件夹图标，在弹出界面中选择Ascend-cann-toolkit开发套件包的安装路径（需要选择到版本号一级）。选择完成后点击Finish开始安装。2.3.5安装MindX SDKMindX SDK提供昇腾AI处理器加速的各类AI软件开发套件(SDK)，提供极简易用的API，加速AI应用开发。MindX SDK安装过程如下：1. 从菜单栏中点击File → Settings，并在弹出的窗口中选择Appearance & Behavior → System Settings → MindX SDK进入MindX SDK管理界面，如图2-22所示。图2-22 MindX SDK管理界面2. 界面中“MindX SDK Location”为软件包的默认安装路径，默认安装路径为 “C:\Users\用户名\Ascend\mindx_sdk”。单击Install SDK进入Installation settings界面，如图2-23所示。图2-23 MindX SDK安装3. 上图中前两个参数“Remote Connection”与“Remote CANN location”，跟图2-21中的选择保持一致；第三个参数“Remote SDK location”为远端环境SDK的路径，需配置到版本号一级；第四个参数“Local SDK location”为SDK的本地安装路径，图2-24所示为默认安装路径。选择完成后点击OK开始安装。4. 安装完成后的结果如下，点击OK即可。图2-24 成功安装MindX SDK三、基于双目视觉的目标定位开发3.1创建项目3.1.1创建初始项目1. 首先通过SecoClient连接VPN，以确保MindStudio能够连接远程服务器。启动MindStudio进入图2-8所示窗口，点击New Project，弹出图3-1所示新建项目窗口。2. 命名项目，图文案例把项目命名为BinocularStereoDepthRecovery，选择CANN版本及新建项目位置，点击Next。图3-1 新建昇腾项目3. 在打开的窗口左侧选择Ascend App（如图3-1所示），然后选择MindX SDK Projet(Python)（如图3-2所示），点击Finish。图3-2 选择MindX SDK Projet(Python)类型4. 项目创建完成后的初始界面如图3-3所示。图3-3 新建昇腾项目初始界面3.1.2项目文件介绍为新建昇腾项目创建“基于双目视觉的目标定位”所需文件。创建完毕后，BinocularStereoDepthRecovery项目目录树在MindStudio的显示如图3-4所示。图3-4 所需文件创建完毕的昇腾项目其中，image目录存放测试图片，每两个为一组，是我们用自制双目相机同时获取场景物体的图像。model目录存放模型文件，模型下载地址为：YOLOv3-昇腾社区。本案例所下载模型可直接使用，无需模型转换过程。若需要模型转换，可点击图3-5中任意一个红框位置，进入图3-6所示界面进行设置，具体过程可参考：模型转换-用户指南。图3-5 进入模型转换图3-6 模型转换设置界面camera_configs.py文件主要代码介绍如图3-7所示。执行该函数会从camera.xml文件中有序地导入相机参数，并计算校正变化。该函数在yolo_deep.py文件中被调用。图3-7 相机配置文件代码介绍camera.xml文件中含有相机预标定的数据，包括相机内参、外参和畸变参数，如图3-8与图3-9所示。图3-8 camera.xml文件中的相机参数信息图3-9 camera.xml文件中的相机参数信息yolo_deep.py文件计算物体坐标，主要代码介绍如图3-10与图3-11所示。图3-10 物体坐标计算文件代码介绍图3-11 物体坐标计算文件代码介绍yolov3_infer.py为模型推理文件，主要代码介绍如图3-12与图3-13所示。图3-12 模型推理文件代码介绍图3-13 模型推理文件代码介绍3.1.3接口调用介绍本模型采用API接口实现流程编排，对API的调用可参见第一章中“双目视觉目标定位流程的主要步骤”，代码中调用API的地方如下图所示。图3-14 yolo_deep.py文件中对API的调用图3-15 模型推理文件中对API的调用图3-16 模型推理文件中对API的调用如果需要进行pipeline编排，可在MindStudio顶部菜单栏中选择Ascend下的MindX SDK Pipeline，如图3-17所示，进入pipeline绘制界面，详细的pipeline绘制过程可参考可视化流程编排-用户指南。图3-17 打开pipeline绘制界面3.1.4连接远程终端       1. 选择MindStudio Tools菜单的Start SSH session菜单项，如图3-18所示。图3-18 打开Tools菜单选择“Start SSH session…”       在弹出的对话框中选择要连接的远程终端服务器，如图3-19所示。图3-19 选择远程终端连接的服务器       远程终端开启后，点击MindStudio底部状态栏目的Remote Terminal图标，如图3-20所示。图3-20 打开远程终端2. 激活远程终端mxVision的环境变量在远程终端窗口输入指令“vim ~/.bashrc”，在打开的文件末尾添加图3-21红框中内容（该内容从mxVision目录下的set_env.sh文件中复制得到），添加完成后在末行输入“wq!”保存并退出。最后，输入指令“source ~/.bashrc”使环境变量生效。图3-21 设置远程终端mxVision环境变量3. Deployment配置从顶部菜单栏中选择Tools → Deployment → Configuration，如图3-22所示。图3-22 打开Deployment Configuration新弹出的界面如图3-23所示。图3-23 Deployment Configuration界面点击上图中红框位置处的加号，在弹出的对话框中输入new server name。点击OK后Deployment Configuration界面如图3-24。在Connection模块下，Type项选择SFTP，SSH configuration项选择要连接的远程服务器。图3-24 Deployment界面的Connection模块在Mappings模块下，Local path已给出，保持不变；点击Deployment path后的文件夹图标，会弹出一个指定的目录，选择该默认路径即可。图3-25 Deployment界面的Mappings模块返回Connection模块，点击Test Connection，出现图3-26所示界面则代表连接成功，点击OK。然后依次点击Deployment Configuration界面的Apply与OK，完成配置。图3-26 成功连接服务器4. 如图3-27所示，把鼠标放在项目名上，单击鼠标右键，在弹出的菜单项中选择Deployment下的Upload to，在新弹出的对话框中选择所连接的服务器。执行该操作会把MindStudio本地客户端的项目文件会同步到服务器端。图3-27 同步项目文件到服务器端执行完毕后，会看到MindStudio界面下方的File Transfer窗口中显示如下。图3-28 同步成功提示信息进入服务器端，可以看到新生成了一个MindStudio-WorkSpace目录，如下图所示。图3-29 MindX服务器生成工作目录       进入MindStudio-WorkSpace目录，含有BinocularStereoDepthRecovery项目所在目录，如图3-30中红框所示。图3-30 服务器端创建的项目目录       进入到BinocularStereoDepthRecovery项目目录，可以看到从MindStudio本地客户端同步至服务器端的项目文件，目录信息如图3-31所示。图3-31 服务器端项目目录情况3.2运行项目       选择顶部菜单栏Run下的Edit Configurations菜单项，如图3-32所示。图3-32 打开Edit Configurations弹出的窗口如图3-33所示。在窗口左侧，我们选择Ascend App下的项目名；在窗口右侧，Deployment项是前面已经设置过的，Executable项选择此次要执行函数yolo_deep.py的路径。选择完成后点击OK。图3-33 Run Configurations界面设定完要运行的函数后，点击MindStudio界面的程序运行按钮，即下图中红框内的蓝色三角号，便可执行yolo_deep.py程序。图3-34 程序运行按钮 基于双目视觉的目标定位运行结果如图3-35所示。对于输入的两张（用双目相机拍摄的）图像，输出检测到的物体像素坐标，并且输出物体的世界坐标以及物体与相机的距离。图3-35 深度推理结果图3-36为输入图像中的其中一幅，图3-35中输出的距离便是红色汽车模型与相机之间的距离。此外，我们生成了相对应的深度图，如图3-37所示。深度图中越亮的部分表示与相机的距离越近，越暗的部分与相机的距离越远。图3-36 输入图像图3-37 输入图像对应的深度图四、FAQ1. No Python interpreter configured for the module答：未配置Python解释器，可参考2.3.1节中的步骤6配置Python解释器。2. Get MindX SDK version failed!答：选择远程服务器中SDK路径时，没有选择到版本号一级，选择父路径时会提示SDK版本获取失败。可参考2.3.5节完成MindX SDK的安装。3. CANN 连接错误（连接服务器 SSH 成功，但是连接 CANN 失败）答：有可能是没有选择到版本号一级，选择父路径时会报错，也有可能是因为当前用户非 root 用户，还有可能是服务器端内存不足。查看同步 CANN 运行日志可判断缘由，可在服务器端的log目录下查看日志文件。       开发者在使用 MindStudio 或进行算子开发过程中遇到任何问题，都可以在昇腾社区进行互动，提出问题，获得更多的帮助。 昇腾官网：cid:link_8 昇腾博客：cid:link_5 昇腾论坛：cid:link_6   

视频伪装物体检测1 介绍基于 MindX SDK 实现 SLT-Net 模型的推理，在 MoCA-Mask 数据集上 Sm 达到大于 0.6。输入连续几帧伪装物体的视频序列，输出伪装物体掩膜 Mask 图。1.1 支持的产品支持昇腾310芯片1.2 支持的版本支持的SDK版本：SDK3.0 RC2版本号查询方法，在Atlas产品环境下，运行命令：npu-smi info1.3 软件方案介绍本方案中，先通过 torch2onnx.py 脚本将 PyTorch 版本的伪装视频物体检测模型 SLT-Net 转换为 onnx 模型；然后通过 inference.py 脚本调用晟腾om模型，将输入视频帧进行图像处理，最终生成视频伪装物体的掩膜 Mask 图。1.4 代码目录结构与说明本sample工程名称为 VCOD_SLTNet，工程目录如下图所示：──VCOD_SLTNet ├── flowchart.jpeg ├── inference.py # 推理文件 ├── torch2onnx.py # 模型转换脚本 └── README.md本项目的代码地址为：cid:link_21.5 技术实现流程图图1 视频伪装物体检测流程图1.6 特性及适用场景对于伪装视频数据的分割任务均适用，输入视频需要转换为图片序列输入到模型中，具体可以参考 MoCA 数据格式与目录结构（如下所示），详见 SLT-Net 与 MoCA 数据集主页。--data └── TestDataset_per_sq # 测试数据集 ├── flower_crab_spider_1 # 不同场景 ├── GT # Ground Truth ├── 00000.png ├── ..... └── Imgs # 输入图片序列 ├── 00000.jpg ├── ..... ......2 环境依赖环境依赖软件和版本如下表：软件名称版本MindX SDKmxVision-3.0.RC2Python3.9.2CANN5.1RC2PyTorch1.12.1numpy1.21.5imageio2.22.3Pillow9.3.0cv24.5.5timm0.4.12tqdm4.64.13. 数据准备3.1 准备相关文件1、SLT-Net代码包准备点击访问 SLT-Net 并下载 SLT-Net-master.zip 代码压缩包，上传服务器并解压得到“SLT-Net-master”目录及文件；2、SLT-Net模型文件准备方法一：通过访问 SLT-Net 模型官方链接 下载模型压缩包 (注意，需要访问 Google Drive )，解压后将 Net_epoch_MoCA_short_term_pseudo.pth 模型拷贝至 SLT-Net-master 目录下；方法二：下载 models.zip 备份模型压缩包 并解压获得 sltnet.pth、sltnet.onnx、sltnet.om 三个模型文件，将 sltnet.pth 模型拷贝至 SLT-Net-master 目录下3、数据集准备通过访问MoCA官方链接下载 MoCA_Video 数据集，或者通过数据集备份链接来下载 MoCA_Video.zip 数据集压缩包并解压；3.2 模型转换1、SLT-Net代码预处理进入 SLT-Net-master/lib 目录下，对 __init__.py、short_term_model.py、pvtv2_afterTEM.py三个文件做以下修改：1）__init__.py文件注释如下：from .short_term_model import VideoModel as VideoModel_pvtv2 # from .long_term_model import VideoModel as VideoModel_long_term注：因为长期模型依赖 CUDA，并且需要在 CUDA 平台进行编译，而本项目基于 MindX SDK 实现，因此使用短期模型。并且，短期模型的评价指标满足预期。2）修改 short_term_model.py 文件中，如下代码行：修改def forward(self, x): image1, image2, image3 = x[:, :3], x[:, 3:6], x[:, 6:] # 替换之前的 image1, image2, image3 = x[0],x[1],x[2] fmap1=self.backbone.feat_net(image1) fmap2=self.backbone.feat_net(image2) fmap3=self.backbone.feat_net(image3)修改 def __init__(self, args): super(ImageModel, self).__init__() self.args = args # self.backbone = Network(pvtv2_pretrained=self.args.pvtv2_pretrained, imgsize=self.args.trainsize) self.backbone = Network(pvtv2_pretrained=self.args.pvtv2_pretrained, imgsize=352) # 指定图片大小 .... # self.backbone = Network(pvtv2_pretrained=False, imgsize=self.args.trainsize) self.backbone = Network(pvtv2_pretrained=False, imgsize=352) # 指定图片大小 if self.args.pretrained_cod10k is not None: self.load_backbone(self.args.pretrained_cod10k )删除if self.args.pretrained_cod10k is not None: self.load_backbone(self.args.pretrained_cod10k )3）pvtv2_afterTEM.py 文件注释如下：from timm.models import create_model #from mmseg.models import build_segmentor #from mmcv import ConfigDict import pdb修改“SLT-Net-master/mypath.py”文件如下：elif dataset == 'MoCA': return './dataset/MoCA-Mask/' # 将此处路径修改指定为“MoCA_Video”目录的相对路径可参考已经完成修改的 SLT_Net_MindXsdk_torch，也可直接使用该项目进行下面的 onnx 模型转换操作，替代以上步骤。2、模型转换步骤一、pth模型转onnx模型将 VCOD_SLTNet 代码包中的 torch2onnx.py 脚本拷贝至 SLT-Net-master 目录下，并在 SLT-Net-master 目录下执行以下命令将 pth 模型转换成 onnx 模型：python torch2onnx.py --pth_path ${pth模型文件路径} --onnx_path ./sltnet.onnx参数说明：pth_path：pth模型文件名称及所在路径onnx_path：生成输出的onnx模型文件注意，timm 的版本为 0.4.12，其他版本可能有兼容性问题。步骤二、简化onnx文件（可选操作）python -m onnxsim --input-shape="1,9,352,352" --dynamic-input-shape sltnet.onnx sltnet_sim.onnx步骤三、onnx模型转om模型atc --framework=5 --model=sltnet.onnx --output=sltnet --input_shape="image:1,9,352,352" --soc_version=Ascend310 --log=error注意：若想使用转换好的onnx模型或om模型，可通过下载 models.zip备份模型压缩包 解压获得转换好的 onnx 模型或 om 模型。pth模型转onnx模型，onnx模型转om模型，均可能花费约1小时左右，视不同运行环境而定。如无报错，请耐心等待。4. 运行推理使用如下命令，运行 inference.py 脚本：python inference.py --datapath ${MoCA_Video数据集路径} --save_root ./results/ --om_path ./sltnet.om --testsize 352 --device_id 0参数说明：datapath：下载数据以后，目录中 TestDataset_per_sq 的上一级目录，save_root：结果保存路径om_path：om 模型路径testsize：图片 resize 的大小，当前固定为 352device_id：设备编号注意，该脚本无需放入修改的 SLT-Net 目录，在任意位置均可执行，只需设置好上述参数即可。运行输出如下： 0%| | 0/713 [00:00<?, ?it/s]> ./results/arctic_fox/Pred/00000.png 0%|▏ | 1/713 [00:00<10:31, 1.13it/s]> ./results/arctic_fox/Pred/00005.png 0%|▎ | 2/713 [00:01<09:01, 1.31it/s]> ./results/arctic_fox/Pred/00010.png 0%|▍ | 3/713 [00:02<08:30, 1.39it/s]> ./results/arctic_fox/Pred/00015.png 1%|▌ | 4/713 [00:02<08:13, 1.44it/s]> ./results/arctic_fox/Pred/00020.png将展示剩余运行时间以及生成图片的路径。5. 精度评估点击访问 SLT_Net_MindXsdk_torch 并下载 SLT_Net_MindXsdk_torch-master.zip 代码压缩包，上传服务器并解压获得 SLT_Net_MindXsdk_torch-master 目录及相关文件；进入 SLT_Net_MindXsdk_torch-master 目录，修改 eval_python/run_eval.py 脚本中的 gt_dir 为本地的 MoCA_Video/TestDataset_per_sq/ 目录的绝对路径，pred_dir 为预测结果目录的绝对路径，并执行以下命令进行精度评估：python eval_python/run_eval.py完成评估后的结果如下：{'Smeasure': 0.6539, 'wFmeasure': 0.3245, 'MAE': 0.0161, 'adpEm': 0.6329, 'meanEm': 0.7229, 'maxEm': 0.7554, 'adpFm': 0.3025, 'meanFm': 0.3577, 'maxFm': 0.3738}评测结果高于交付所要求的 Smeasure 0.6 的指标。注：评估还可参考基于 基于 MATLAB 的 SLT-Net 的评测代码或参考基于 Python 的 PySODEvalToolkit 的评测代码。

使用的是mindspore1.7版本源代码为

麻烦帮忙看下这个问题，实在找不到原因

打开摄像机页面的配置-》音视频-》音频-》告警联动，点击“试听”没有声音。如果不需要其他外接设备，怎么出声？如果需要外接功放设备，摄像机上也没有其他接口，怎么接呢？

和在组织内值得进行的所有创新一样，你应该选择一种有策略的方式来实现计算机视觉项目。利用计算机视觉技术实现成功创新取决于整体业务策略、资源和数据。以下问题可以帮助你为计算机视觉项目构建战略路线图。1、计算机视觉解决方案应该降低成本还是增加收益？成功的计算机视觉项目要么降低成本要么提高收益（或者二者兼顾），你应该定义该项目的目标。只有这样，它才能对组织及其发展产生重要影响。2、如何衡量项目的成功？每个计算机视觉项目都是不同的，你需要定义一个特定于该项目的成功指标。设置好指标后，你应该确保它被业务人员和数据科学家等认可。3、能否保证信息的获取？开启计算机视觉项目时，数据科学家应该能够轻松访问数据。他们需要和来自不同部门（如 IT 部门）的重要同事合作。这些同事应以其业务知识提供支持，内部官僚主义则会成为主要约束。4、 组织收集的数据是否合适？计算机视觉算法并非魔法。它们需要数据才能运作，输入数据的质量决定其性能。有多种不同方法和来源可供收集合适数据，这取决于你的目标。无论如何，拥有的输入数据越多，计算机视觉模型性能优秀的可能性越大。如果你对数据的量和质存在疑虑，你可以请数据科学家帮忙评估数据集质量，必要情况下，找到获取第三方数据的最优方式。5. 组织是否以恰当格式收集数据？除了拥有合适量和类型的数据以外，你还需要确保数据的格式。假设你使用数千张完美的手机照片（分辨率高，背景为白色）训练目标检测算法。然后发现算法无法运行，因为实际用例是在不同光照/对比度/背景条件下检测持有手机的人，而不是检测手机本身。这样你之前的数据收集努力基本上就作废了，你还需要重头再来。此外，你应该了解，如果数据存在偏见，算法会学到该偏见。

计算机视觉完成的任务远超其他领域，如图像处理、机器视觉，尽管它们存在一些共同点。接下来，我们就来了解一下这些领域之间的差异。图像处理图像处理旨在处理原始图像以应用某种变换。其目标通常是改进图像或将其作为某项特定任务的输入，而计算机视觉的目标是描述和解释图像。例如，降噪、对比度或旋转操作这些典型的图像处理组件可以在像素层面执行，无需对图像整体具备全面的了解。机器视觉机器视觉是计算机视觉用于执行某些（生产线）动作的特例。在化工行业中，机器视觉系统可以检查生产线上的容器（是否干净、空置、无损）或检查成品是否恰当封装，从而帮助产品制造。计算机视觉计算机视觉可以解决更复杂的问题，如人脸识别、详细的图像分析（可帮助实现视觉搜索，如 Google Images），或者生物识别方法。

MindX SDK -- TextSnake弯曲形状文字检测参考设计1 案例概述1.1 概要描述在本系统中，目的是基于MindX SDK，在华为云昇腾平台上，开发端到端TextSnake弯曲形状文字检测的参考设计，实现对图像中的弯曲形状文字进行检测的功能，达到功能要求1.2 模型介绍本项目主要用到了TextSnake模型TextSnake模型相关文件可以在此处下载：cid:link_21.3 实现流程1、基础环境：Ascend 310、mxVision、Ascend-CANN-toolkit、Ascend Driver2、模型转换：onnx模型转昇腾离线模型： TextSnake.onnx --> TextSnake_bs1.om3、业务流程编排与配置4、python推理流程代码开发 技术流程图如下：1.4 代码地址本项目的代码地址为：cid:link_62 软件方案介绍2.1 项目方案架构介绍本系统设计了不同的功能模块。主要流程为：图片传入流中，利用TextSnake的检测模型检测弯曲形状文字，最后根据检测结果绘制检测框。各模块功能描述如表2.1所示：表2.1 系统方案中各模块功能：序号子系统功能描述1图像输入调用MindX SDK的appsrc输入图片2弯曲形状文字检测利用TextSnake的检测模型，检测出图片中弯曲形状文字的位置形状信息3后处理使用检测出的位置形状信息在原图上绘制检测框4结果输出将检测结果输出2.2 代码目录结构与说明本工程名称为TextSnake，工程目录如下图所示：├── main.py //运行工程项目的主函数 ├── evaluate.py //精度计算 ├── t.pipeline //pipeline ├── model //存放模型文件 ├── test.jpg //测试图像 ├── result.jpg //输出结果 ├── sdk.png //流程图 ├── pipeline.png //pipeline流程图 └──README.md 3 开发准备3.1 环境依赖说明环境依赖软件和版本如下表：软件名称版本MindX SDK2.0.4Ascend-CANN-toolkit5.0.4ubuntu18.04.1 LTSpython3.9.2cv24.1.2numpy1.15.1onnx1.8.0torch1.5.0torchvision0.6.0scikit_image0.16.2scipy1.5.4easydict1.8tdqm4.62.33.2 环境搭建3.2.1 环境变量设置. ${MX_SDK_HOME}/set_env.sh . ${ascend-toolkit-path}/set_env.sh3.3 模型转换3.3.1 TextSnake模型转换步骤1 在ModelZoo上下载TextSnake模型。下载地址：cid:link_3步骤2 将获取到的TextSnake模型onnx文件存放至./model。步骤3 模型转换在./model目录下执行一下命令atc --model=TextSnake.onnx --framework=5 --output=TextSnake_bs1 --input_format=NCHW --input_shape="image:1,3,512,512" --log=info --soc_version=Ascend310执行完模型转换脚本后，会生成相应的TextSnake_bs1.om模型文件。4 弯曲形状文字检测流程开发实现4.1 pipeline编排 appsrc # 输入 mxpi_tensorinfer # 模型推理（弯曲形状文字检测） mxpi_dataserialize #数据序列化 appsink # 输出4.2 主程序开发1、初始化流管理。2、加载图像，进行推理。3、获取pipeline各插件输出结果，解析输出结果。4、根据识别结果在图上绘制检测框5、销毁流5 编译与运行示例步骤如下：步骤 1 将任意一张jpg格式的图片存到当前目录下（./TextSnake），命名为test.jpg。如果 pipeline 文件（或测试图片）不在当前目录下（./TestSnake），需要修改 main.py 的pipeline（或测试图片）路径指向到所在目录。此外，需要从 cid:link_1 下载util文件夹至当前目录（./TextSnake），并修改其中的detection.py,修改方式如下（以下行数均为原代码行数）：（1）将12行改为：def __init__(self, tr_thresh=0.4, tcl_thresh=0.6):并删除该构造函数中与model相关的语句。（2）将38行：in_poly = cv2.pointPolygonTest(cont, (xmean, i), False)改为in_poly = cv2.pointPolygonTest(cont, (int(xmean), int(i)), False)56行改为if cv2.pointPolygonTest(cont, (int(test_pt[0]), int(test_pt[1])), False) > 067行改为return cv2.pointPolygonTest(cont, (int(x), int(y)), False) > 0（3）在315行前后分别添加：conts = list(conts)conts = tuple(conts)步骤2执行python3 main.py6 测试精度步骤 1 安装数据集用以测试精度。数据集 TotalText 需要自行下载。 数据集图片部分： cid:link_4 totaltext.zip数据集ground truth部分： cid:link_5 groundtruth_text.zip将下载好的数据集调整成以下路径的形式├── main.py //运行工程项目的主函数 ├── evaluate.py //精度计算 ├── t.pipeline //pipeline ├── model //存放模型文件 ├── test.jpg //测试图像 ├── result.jpg //输出结果 ├── sdk.png //流程图 ├── pipeline.png //pipeline流程图 ├── data ├── total-text ├── gt ├── Test ├── poly_gt_img1.mat //测试集groundtruth ... ├── img1.jpg //测试集图片 ... └──README.md 步骤 2 除先前下载的util文件夹之外，还需要从以下网址中下载Deteval.py与polygon_wrapper.py文件，放入util文件夹中 cid:link_0步骤 3 在命令行输入 如下命令运行精度测试python3 evaluate.py得到精度测试的结果：与pytorch实现版本的精度结果相对比，其精度相差在1%以下，精度达标。7 参考链接cid:link_7

MindX SDK -- 伪装目标分割参考设计案例1 案例概述1.1 概要描述在本系统中，目的是基于MindX SDK，在华为云昇腾平台上，开发端到端伪装目标分割的参考设计，实现对图像中的伪装目标进行识别检测的功能，达到功能要求1.2 模型介绍本项目主要基于用于通用伪装目标分割任务的DGNet模型模型的具体描述和细节可以参考原文：cid:link_4具体实现细节可以参考基于PyTorch深度学习框架的代码：cid:link_3所使用的公开数据集是NC4K，可以在此处下载：cid:link_1所使用的模型是EfficientNet-B4版本的DGNet模型，原始的PyTorch模型文件可以在此处下载：cid:link_01.3 实现流程基础环境：Ascend 310、mxVision、Ascend-CANN-toolkit、Ascend Driver模型转换：将ONNX模型（.onnx）转换为昇腾离线模型（.om）昇腾离线模型推理流程代码开发1.4 代码地址本项目的代码地址为：cid:link_21.5 特性及适用场景本项目适用于自然场景下图片完整清晰、无模糊鬼影的场景，并且建议输入图片为JPEG编码格式，大小不超过10M。注意：由于模型限制，本项目暂只支持自然场景下伪装动物的检测，不能用于其他用途2 软件方案介绍2.1 项目方案架构介绍本系统设计了不同的功能模块。主要流程为：图片传入流中，利用DGNet检测模型检测伪装目标，将检测出的伪装目标以逐像素概率图的形式输出，各模块功能描述如表2.1所示：表2.1 系统方案中各模块功能：序号子系统功能描述1图像输入调用cv2中的图片加载函数，用于加载输入图片2图像前处理将输入图片放缩到352*352大小，并执行归一化操作3伪装目标检测利用DGNet检测模型，检测出图片中的伪装目标4数据分发将DGNet模型检测到的逐像素概率图进行数据分发到下个插件5结果输出将伪装目标概率预测图结果进行输出并保存2.2 代码目录结构与说明本工程名称为DGNet，工程目录如下列表所示：./ ├── assets # 文件 │ ├── 74.jpg │ └── 74.png ├── data # 数据集存放路径 │ └── NC4K ├── inference_om.py # 昇腾离线模型推理python脚本文件 ├── README.md # 本文件 ├── seg_results_om │ ├── Exp-DGNet-OM # 预测结果图存放路径 ├── snapshots │ ├── DGNet # 模型文件存放路径3 开发准备3.1 环境依赖说明环境依赖软件和版本如下表：软件名称版本ubantu18.04.1 LTSMindX SDK2.0.4Python3.9.2CANN5.0.4numpy1.21.2opencv-python4.5.3.56mindspore (cpu)1.9.03.2 环境搭建在编译运行项目前，需要设置环境变量# MindXSDK 环境变量： . ${SDK-path}/set_env.sh # CANN 环境变量： . ${ascend-toolkit-path}/set_env.sh # 环境变量介绍 SDK-path: SDK mxVision 安装路径 ascend-toolkit-path: CANN 安装路径3.3 模型转换步骤1 下载DGNet (Efficient-B4) 的ONNX模型：cid:link_0步骤2 将下载获取到的DGNet模型onxx文件存放至./snapshots/DGNet/DGNet.onnx。步骤3 模型转换具体步骤# 进入对应目录 cd ./snapshots/DGNet/ # 执行以下命令将ONNX模型（.onnx）转换为昇腾离线模型（.om） atc --framework=5 --model=DGNet.onnx --output=DGNet --input_shape="image:1,3,352,352" --log=debug --soc_version=Ascend310执行完模型转换脚本后，会在对应目录中获取到如下转化模型：DGNet.om（本项目中在Ascend平台上所使用的离线模型文件）。4 推理与评测示例步骤如下：步骤0参考1.2节中说明下载一份测试数据集合：下载链接：cid:link_1步骤1执行离线推理Python脚本python inference_om.py --om_path ./snapshots/DGNet/DGNet.om --save_path ./seg_results_om/Exp-DGNet-OM/NC4K/ --data_path ./data/NC4K/Imgs 步骤2定量性能验证：使用原始GitHub仓库中提供的标准评测代码进行测评，具体操作步骤如下：# 拉取原始仓库 git clone https://github.com/GewelsJI/DGNet.git # 将如下两个文件夹放入当前 mv ./DGNet/lib_ascend/eval ./contrib/CamouflagedObjectDetection/ mv ./DGNet/lib_ascend/evaluation.py ./contrib/CamouflagedObjectDetection/ # 运行如下命令进行测评 python evaluation.py然后可以生成评测指标数值表格。可以看出DGNet模型的Smeasure指标数值为0.856，已经超过了项目交付中提到的“大于0.84”的要求。+---------+-----------------------+----------+-----------+-------+-------+--------+-------+-------+--------+-------+ | Dataset | Method | Smeasure | wFmeasure | MAE | adpEm | meanEm | maxEm | adpFm | meanFm | maxFm | +---------+-----------------------+----------+-----------+-------+-------+--------+-------+-------+--------+-------+ | NC4K | Exp-DGNet-OM | 0.856 | 0.782 | 0.043 | 0.909 | 0.91 | 0.921 | 0.8 | 0.812 | 0.833 | +---------+-----------------------+----------+-----------+-------+-------+--------+-------+-------+--------+-------+定性性能验证：输入伪装图片：预测分割结果：5 参考引用主要参考为如下三篇论文：@article{ji2022gradient, title={Deep Gradient Learning for Efficient Camouflaged Object Detection}, author={Ji, Ge-Peng and Fan, Deng-Ping and Chou, Yu-Cheng and Dai, Dengxin and Liniger, Alexander and Van Gool, Luc}, journal={Machine Intelligence Research}, year={2023} } @article{fan2021concealed, title={Concealed Object Detection}, author={Fan, Deng-Ping and Ji, Ge-Peng and Cheng, Ming-Ming and Shao, Ling}, journal={IEEE TPAMI}, year={2022} } @inproceedings{fan2020camouflaged, title={Camouflaged object detection}, author={Fan, Deng-Ping and Ji, Ge-Peng and Sun, Guolei and Cheng, Ming-Ming and Shen, Jianbing and Shao, Ling}, booktitle={IEEE CVPR}, pages={2777--2787}, year={2020} }

实例分割-Mask R-CNN 模型本案例我们将进行实例分割模型Mask R-CNN的训练和测试的学习。在计算机视觉领域，实例分割(Instance Segmentation)是指从图像中识别物体的各个实例，并逐个将实例进行像素级标注的任务。实例分割技术在自动驾驶、医学影像、高精度GIS识别、3D建模辅助等领域有广泛的应用。本案例将对实例分割领域经典的Mask R-CNN模型进行简单介绍，并使用Matterport开源Mask R-CNN实现,展示如何在华为云ModelArts上训练Mask R-CNN模型。点击跳转至Mask R-CNN模型详解注意事项：本案例使用框架**:** TensorFlow-1.13.1本案例使用硬件规格**:** 8 vCPU + 64 GiB + 1 x Tesla V100-PCIE-32GB进入运行环境方法：点此链接进入AI Gallery，点击Run in ModelArts按钮进入ModelArts运行环境，如需使用GPU,您可以在ModelArts JupyterLab运行界面右边的工作区进行切换运行代码方法**:** 点击本页面顶部菜单栏的三角形运行按钮或按Ctrl+Enter键 运行每个方块中的代码JupyterLab的详细用法**:** 请参考《ModelAtrs JupyterLab使用指导》碰到问题的解决办法**:** 请参考《ModelAtrs JupyterLab常见问题解决办法》1.首先进行包的安装与引用!pip install pycocotools==2.0.0Collecting pycocotools==2.0.0 Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/96/84/9a07b1095fd8555ba3f3d519517c8743c2554a245f9476e5e39869f948d2/pycocotools-2.0.0.tar.gz (1.5MB)  100% |████████████████████████████████| 1.5MB 52.3MB/s ta 0:00:01 [?25hBuilding wheels for collected packages: pycocotools Running setup.py bdist_wheel for pycocotools ... [?25ldone [?25h Stored in directory: /home/ma-user/.cache/pip/wheels/63/72/9e/bac3d3e23f6b04351d200fa892351da57f0e68c7aeec0b1b08 Successfully built pycocotools Installing collected packages: pycocotools Successfully installed pycocotools-2.0.0 You are using pip version 9.0.1, however version 21.0.1 is available. You should consider upgrading via the 'pip install --upgrade pip' command.!pip install imgaug==0.2.9Collecting imgaug==0.2.9 Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/17/a9/36de8c0e1ffb2d86f871cac60e5caa910cbbdb5f4741df5ef856c47f4445/imgaug-0.2.9-py2.py3-none-any.whl (753kB)  100% |████████████████████████████████| 757kB 83.4MB/s ta 0:00:01 91% |█████████████████████████████▏ | 686kB 83.9MB/s eta 0:00:01 [?25hRequirement already satisfied: numpy>=1.15.0 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from imgaug==0.2.9) Requirement already satisfied: opencv-python in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from imgaug==0.2.9) Requirement already satisfied: matplotlib in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from imgaug==0.2.9) Requirement already satisfied: Pillow in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from imgaug==0.2.9) Requirement already satisfied: scikit-image>=0.11.0 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from imgaug==0.2.9) Requirement already satisfied: six in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from imgaug==0.2.9) Collecting Shapely (from imgaug==0.2.9) Downloading http://repo.myhuaweicloud.com/repository/pypi/packages/9d/18/557d4f55453fe00f59807b111cc7b39ce53594e13ada88e16738fb4ff7fb/Shapely-1.7.1-cp36-cp36m-manylinux1_x86_64.whl (1.0MB)  100% |████████████████████████████████| 1.0MB 40.5MB/s ta 0:00:01 [?25hRequirement already satisfied: imageio in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from imgaug==0.2.9) Requirement already satisfied: scipy in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from imgaug==0.2.9) Requirement already satisfied: python-dateutil>=2.1 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from matplotlib->imgaug==0.2.9) Requirement already satisfied: pytz in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from matplotlib->imgaug==0.2.9) Requirement already satisfied: kiwisolver>=1.0.1 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from matplotlib->imgaug==0.2.9) Requirement already satisfied: cycler>=0.10 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from matplotlib->imgaug==0.2.9) Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from matplotlib->imgaug==0.2.9) Requirement already satisfied: cloudpickle>=0.2.1 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from scikit-image>=0.11.0->imgaug==0.2.9) Requirement already satisfied: PyWavelets>=0.4.0 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from scikit-image>=0.11.0->imgaug==0.2.9) Requirement already satisfied: networkx>=1.8 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from scikit-image>=0.11.0->imgaug==0.2.9) Requirement already satisfied: decorator>=4.1.0 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from networkx>=1.8->scikit-image>=0.11.0->imgaug==0.2.9) Installing collected packages: Shapely, imgaug Found existing installation: imgaug 0.2.6 Uninstalling imgaug-0.2.6: Successfully uninstalled imgaug-0.2.6 Successfully installed Shapely-1.7.1 imgaug-0.2.9 You are using pip version 9.0.1, however version 21.0.1 is available. You should consider upgrading via the 'pip install --upgrade pip' command.2.对需要的代码和数据进行下载import os from modelarts.session import Session session = Session() if session.region_name == 'cn-north-1': bucket_path="modelarts-labs/end2end/mask_rcnn/instance_segmentation.tar.gz" elif session.region_name == 'cn-north-4': bucket_path="modelarts-labs-bj4/end2end/mask_rcnn/instance_segmentation.tar.gz" else: print("请更换地区到北京一或北京四") if not os.path.exists('./src/mrcnn'): session.download_data(bucket_path=bucket_path, path='./instance_segmentation.tar.gz') if os.path.exists('./instance_segmentation.tar.gz'): # 使用tar命令解压资源包 os.system("tar zxf ./instance_segmentation.tar.gz") # 清理压缩包 os.system("rm ./instance_segmentation.tar.gz")Successfully download file modelarts-labs-bj4/end2end/mask_rcnn/instance_segmentation.tar.gz from OBS to local ./instance_segmentation.tar.gz3.Mask R-CNN模型训练部分3.1 第一步：导入相应的Python库，准备预训练模型import sys import random import math import re import time import numpy as np import cv2 import matplotlib import matplotlib.pyplot as plt from src.mrcnn.config import Config from src.mrcnn import utils import src.mrcnn.model as modellib from src.mrcnn import visualize from src.mrcnn.model import log %matplotlib inline # Directory to save logs and trained model MODEL_DIR = "logs" # Local path to trained weights file COCO_MODEL_PATH = "data/mask_rcnn_coco.h5"/home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'. _np_qint8 = np.dtype([("qint8", np.int8, 1)]) /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'. _np_quint8 = np.dtype([("quint8", np.uint8, 1)]) /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:528: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'. _np_qint16 = np.dtype([("qint16", np.int16, 1)]) /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:529: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'. _np_quint16 = np.dtype([("quint16", np.uint16, 1)]) /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:530: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'. _np_qint32 = np.dtype([("qint32", np.int32, 1)]) /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:535: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'. np_resource = np.dtype([("resource", np.ubyte, 1)]) Using TensorFlow backend.3.2 第二步：生成相关配置项我们定义Config类的子类MyTrainConfig，指定相关的参数，较为关键的参数有：__NAME__： Config的唯一名称__NUM_CLASSES__： 分类的数量，COCO中共有80种物体+背景__IMAGE_MIN_DIM和IMAGE_MAX_DIM__： 图片的最大和最小尺寸，我们生成固定的128x128的图片，因此都设置为128__TRAIN_ROIS_PER_IMAGE__： 每张图片上训练的RoI个数__STEPS_PER_EPOCH和VALIDATION_STEPS__： 训练和验证时，每轮的step数量，减少step的数量可以加速训练，但是检测精度降低class MyTrainConfig(Config): # 可辨识的名称 NAME = "my_train" # GPU的数量和每个GPU处理的图片数量，可以根据实际情况进行调整，参考为Nvidia Tesla P100 GPU_COUNT = 1 IMAGES_PER_GPU = 1 # 物体的分类个数，COCO中共有80种物体+背景 NUM_CLASSES = 1 + 80 # background + 80 shapes # 图片尺寸统一处理为1024，可以根据实际情况再进一步调小 IMAGE_MIN_DIM = 1024 IMAGE_MAX_DIM = 1024 # 因为我们生成的形状图片较小，这里可以使用较小的Anchor进行RoI检测 # RPN_ANCHOR_SCALES = (8, 16, 32, 64, 128) # anchor side in pixels # 每张图片上训练的RoI个数，因为我们生成的图片较小，而且每张图片上的形状较少 #　因此可以适当调小该参数，用较少的Anchor即可覆盖大致的物体信息 TRAIN_ROIS_PER_IMAGE = 200 # 每轮训练的step数量 STEPS_PER_EPOCH = 100 # 每轮验证的step数量 VALIDATION_STEPS = 20 config = MyTrainConfig() config.display()Configurations: BACKBONE resnet101 BACKBONE_STRIDES [4, 8, 16, 32, 64] BATCH_SIZE 1 BBOX_STD_DEV [0.1 0.1 0.2 0.2] COMPUTE_BACKBONE_SHAPE None DETECTION_MAX_INSTANCES 100 DETECTION_MIN_CONFIDENCE 0.7 DETECTION_NMS_THRESHOLD 0.3 FPN_CLASSIF_FC_LAYERS_SIZE 1024 GPU_COUNT 1 GRADIENT_CLIP_NORM 5.0 IMAGES_PER_GPU 1 IMAGE_CHANNEL_COUNT 3 IMAGE_MAX_DIM 1024 IMAGE_META_SIZE 93 IMAGE_MIN_DIM 1024 IMAGE_MIN_SCALE 0 IMAGE_RESIZE_MODE square IMAGE_SHAPE [1024 1024 3] LEARNING_MOMENTUM 0.9 LEARNING_RATE 0.001 LOSS_WEIGHTS {'rpn_class_loss': 1.0, 'rpn_bbox_loss': 1.0, 'mrcnn_class_loss': 1.0, 'mrcnn_bbox_loss': 1.0, 'mrcnn_mask_loss': 1.0} MASK_POOL_SIZE 14 MASK_SHAPE [28, 28] MAX_GT_INSTANCES 100 MEAN_PIXEL [123.7 116.8 103.9] MINI_MASK_SHAPE (56, 56) NAME my_train NUM_CLASSES 81 POOL_SIZE 7 POST_NMS_ROIS_INFERENCE 1000 POST_NMS_ROIS_TRAINING 2000 PRE_NMS_LIMIT 6000 ROI_POSITIVE_RATIO 0.33 RPN_ANCHOR_RATIOS [0.5, 1, 2] RPN_ANCHOR_SCALES (32, 64, 128, 256, 512) RPN_ANCHOR_STRIDE 1 RPN_BBOX_STD_DEV [0.1 0.1 0.2 0.2] RPN_NMS_THRESHOLD 0.7 RPN_TRAIN_ANCHORS_PER_IMAGE 256 STEPS_PER_EPOCH 100 TOP_DOWN_PYRAMID_SIZE 256 TRAIN_BN False TRAIN_ROIS_PER_IMAGE 200 USE_MINI_MASK True USE_RPN_ROIS True VALIDATION_STEPS 20 WEIGHT_DECAY 0.00013.3 第三步：准备数据集我们使用封装好的CocoDataset类，生成训练集和验证集。from src.mrcnn.coco import CocoDataset COCO_DIR = 'data' # 生成训练集 dataset_train = CocoDataset() dataset_train.load_coco(COCO_DIR, "train") #　加载训练数据集 dataset_train.prepare()loading annotations into memory... Done (t=0.04s) creating index... index created!# 生成验证集 dataset_val = CocoDataset() dataset_val.load_coco(COCO_DIR, "val") #　加载验证数据集 dataset_val.prepare()loading annotations into memory... Done (t=0.17s) creating index... index created!4.创建模型4.1 第一步：用"training"模式创建模型对象，用于形状数据集的训练model = modellib.MaskRCNN(mode="training", config=config, model_dir=MODEL_DIR)WARNING:tensorflow:From /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version. Instructions for updating: Colocations handled automatically by placer. [DEBUG] <__main__.MyTrainConfig object at 0x7f9b6edc7c50> [DEBUG] Tensor("rpn_class/concat:0", shape=(?, ?, 2), dtype=float32) Tensor("rpn_bbox_1/concat:0", shape=(?, ?, 4), dtype=float32) <tf.Variable 'anchors/Variable:0' shape=(1, 261888, 4) dtype=float32_ref>4.2 第二步：加载预训练模型的权重model.load_weights(COCO_MODEL_PATH, by_name=True)接下来，我们使用预训练的模型，结合Shapes数据集，对模型进行训练5.训练模型Keras中的模型可以按照制定的层进行构建，在模型的train方法中，我们可以通过layers参数来指定特定的层进行训练。layers参数有以下几种预设值：heads:只训练head网络中的分类、mask和bbox回归all: 所有的layer3+: 训练ResNet Stage3和后续Stage4+: 训练ResNet Stage4和后续Stage5+: 训练ResNet Stage5和后续Stage此外，layers参数还支持正则表达式，按照匹配规则指定layer，可以调用model.keras_model.summary()查看各个层的名称，然后按照需要指定要训练的层。下面的步骤对所有的layer训练1个epoch，耗时约4分钟model.train(dataset_train, dataset_val, learning_rate=config.LEARNING_RATE, epochs=1, layers='all') model_savepath = 'my_mrcnn_model.h5' model.keras_model.save_weights(model_savepath)Starting at epoch 0. LR=0.001 Checkpoint Path: logs/my_train20210309T1458/mask_rcnn_my_train_{epoch:04d}.h5 WARNING:tensorflow:From /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version. Instructions for updating: Use tf.cast instead. /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/ops/gradients_impl.py:110: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory. "Converting sparse IndexedSlices to a dense Tensor of unknown shape. " /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/keras/engine/training_generator.py:47: UserWarning: Using a generator with `use_multiprocessing=True` and multiple workers may duplicate your data. Please consider using the`keras.utils.Sequence class. UserWarning('Using a generator with `use_multiprocessing=True`' Epoch 1/1 100/100 [==============================] - 111s 1s/step - loss: 0.4283 - rpn_class_loss: 0.0090 - rpn_bbox_loss: 0.0787 - mrcnn_class_loss: 0.0627 - mrcnn_bbox_loss: 0.0758 - mrcnn_mask_loss: 0.2021 - val_loss: 0.4290 - val_rpn_class_loss: 0.0100 - val_rpn_bbox_loss: 0.1086 - val_mrcnn_class_loss: 0.0920 - val_mrcnn_bbox_loss: 0.0539 - val_mrcnn_mask_loss: 0.16456.使用Mask R-CNN 检测图片物体6.1 第一步：定义InferenceConfig，并创建"Inference"模式的模型对象class InferenceConfig(MyTrainConfig): GPU_COUNT = 1 IMAGES_PER_GPU = 1 inference_config = InferenceConfig() inference_model = modellib.MaskRCNN(mode="inference", config=inference_config, model_dir=MODEL_DIR)[DEBUG] <__main__.InferenceConfig object at 0x7f9681f59710> [DEBUG] Tensor("rpn_class_1/concat:0", shape=(?, ?, 2), dtype=float32) Tensor("rpn_bbox_3/concat:0", shape=(?, ?, 4), dtype=float32) Tensor("input_anchors:0", shape=(?, ?, 4), dtype=float32) WARNING:tensorflow:From /home/ma-user/work/case_dev/mask_rcnn/src/mrcnn/model.py:772: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version. Instructions for updating: Use tf.cast instead.将我们生成的模型权重信息加载进来# 加载我们自己训练出的形状模型文件的权重信息 print("Loading weights from ", model_savepath) inference_model.load_weights(model_savepath, by_name=True)Loading weights from my_mrcnn_model.h56.2 第二步：从验证数据集中随机选出一张图片进行预测，并显示结果# 随机选出图片进行测试 image_id = random.choice(dataset_val.image_ids) original_image, image_meta, gt_class_id, gt_bbox, gt_mask =\ modellib.load_image_gt(dataset_val, inference_config, image_id, use_mini_mask=False) log("original_image", original_image) log("image_meta", image_meta) log("gt_class_id", gt_class_id) log("gt_bbox", gt_bbox) log("gt_mask", gt_mask) det_instances_savepath = 'random.det_instances.jpg' visualize.display_instances(original_image, gt_bbox, gt_mask, gt_class_id, dataset_train.class_names, figsize=(8, 8), save_path=det_instances_savepath)original_image shape: (1024, 1024, 3) min: 0.00000 max: 255.00000 uint8 image_meta shape: (93,) min: 0.00000 max: 1024.00000 float64 gt_class_id shape: (17,) min: 1.00000 max: 74.00000 int32 gt_bbox shape: (17, 4) min: 1.00000 max: 1024.00000 int32 gt_mask shape: (1024, 1024, 17) min: 0.00000 max: 1.00000 bool# 定义助手函数用于设置matplot中的子绘制区域所在的行和列 def get_ax(rows=1, cols=1, size=8): _, ax = plt.subplots(rows, cols, figsize=(size*cols, size*rows)) return ax results = inference_model.detect([original_image], verbose=1) r = results[0] prediction_savepath = 'random.prediction.jpg' visualize.display_instances(original_image, r['rois'], r['masks'], r['class_ids'], dataset_val.class_names, r['scores'], ax=get_ax(), save_path=prediction_savepath)Processing 1 images image shape: (1024, 1024, 3) min: 0.00000 max: 255.00000 uint8 molded_images shape: (1, 1024, 1024, 3) min: -123.70000 max: 151.10000 float64 image_metas shape: (1, 93) min: 0.00000 max: 1024.00000 int64 anchors shape: (1, 261888, 4) min: -0.35390 max: 1.29134 float326.3 第三步：测试其他图片。本目录下的data/val2014目录下有很多测试图片，修改下面代码中test_path变量右边的文件名，即可更换为不同图片，测试图片的预测效果。test_path = './data/val2014/COCO_val2014_000000019176.jpg'import skimage.io image = skimage.io.imread(test_path) results = inference_model.detect([image], verbose=1) r = results[0] prediction_savepath = 'self.prediction.jpg' visualize.display_instances(image, r['rois'], r['masks'], r['class_ids'], dataset_val.class_names, r['scores'], ax=get_ax(), save_path=prediction_savepath)Processing 1 images image shape: (480, 640, 3) min: 0.00000 max: 255.00000 uint8 molded_images shape: (1, 1024, 1024, 3) min: -123.70000 max: 151.10000 float64 image_metas shape: (1, 93) min: 0.00000 max: 1024.00000 float64 anchors shape: (1, 261888, 4) min: -0.35390 max: 1.29134 float327.评估模型这一步我们对自己训练出的模型进行一个简单的评估。计算模型的平均精度mAP（mean Average Precision)# 计算VOC类型的 mAP，条件是 IoU=0.5 # 下面的示例中只选出10张图片进行评估，增加图片数量可以增加模型评估的准确性 image_ids = np.random.choice(dataset_val.image_ids, 10) APs = [] for image_id in image_ids: # Load image and ground truth data image, image_meta, gt_class_id, gt_bbox, gt_mask =\ modellib.load_image_gt(dataset_val, inference_config, image_id, use_mini_mask=False) molded_images = np.expand_dims(modellib.mold_image(image, inference_config), 0) # Run object detection results = inference_model.detect([image], verbose=0) r = results[0] # Compute AP AP, precisions, recalls, overlaps =\ utils.compute_ap(gt_bbox, gt_class_id, gt_mask, r["rois"], r["class_ids"], r["scores"], r['masks']) APs.append(AP) print("mAP: ", np.mean(APs))mAP: 0.6203394930987131本案例结束。

使用摄像头进行钢筋盘点案例内容介绍中国的各施工工地每年都要使用大量的钢筋，一车钢筋运到工地现场需要工作人员进行盘点，通常的做法是靠人工一根根数的方式，非常耗时费力。为了提高钢筋盘点效率，业界提出了对钢筋图片进行拍照，然后使用AI算法检测图片中的钢筋条数，实践证明，该方案不仅准确率高，而且可以极大提高效率。本案例基于目标检测的方法，使用250张已经人工标注好的图片进行AI模型的训练，训练25分钟，即可检测出图片中钢筋的横截面，从而统计出钢筋的条数。注意事项本案例推荐使用AI框架：Pytorch-1.0.0；进入运行环境方法：点此链接 进入AI Gallery，点击Run in ModelArts按钮进入ModelArts运行环境，如需使用GPU，可查看《ModelArts JupyterLab 硬件规格使用指南》了解切换硬件规格的方法；如果您是第一次使用 JupyterLab，请查看《ModelArts JupyterLab使用指导》了解使用方法；如果您在使用 JupyterLab 过程中碰到报错，请参考《ModelArts JupyterLab常见问题解决办法》尝试解决问题。实验步骤1.数钢筋案例开始 - 下载代码和数据集import os if not os.path.exists('./rebar_count'): print('Downloading code and datasets...') os.system("wget -N https://modelarts-labs-bj4-v2.obs.cn-north-4.myhuaweicloud.com/notebook/DL_rebar_count/rebar_count_code.zip") os.system("wget -N https://cnnorth4-modelhub-datasets-obsfs-sfnua.obs.cn-north-4.myhuaweicloud.com/content/c2c1853f-d6a6-4c9d-ac0e-203d4c304c88/NkxX5K/dataset/rebar_count_datasets.zip") os.system("unzip rebar_count_code.zip; rm rebar_count_code.zip") os.system("unzip -q rebar_count_datasets.zip; rm rebar_count_datasets.zip") os.system("mv rebar_count_code rebar_count; mv rebar_count_datasets rebar_count/datasets") if os.path.exists('./rebar_count'): print('Download code and datasets success') else: print('Download code and datasets failed, please check the download url is valid or not.') else: print('./rebar_count already exists')./rebar_count already exists2.加载需要的python模块import os import sys sys.path.insert(0, './rebar_count/src') import cv2 import time import random import torch import numpy as np from PIL import Image, ImageDraw import xml.etree.ElementTree as ET from datetime import datetime from collections import OrderedDict import torch.optim as optim import torch.utils.data as data import torch.backends.cudnn as cudnn from data import VOCroot, VOC_Config, AnnotationTransform, VOCDetection, detection_collate, BaseTransform, preproc from models.RFB_Net_vgg import build_net from layers.modules import MultiBoxLoss from layers.functions import Detect, PriorBox from utils.visualize import * from utils.nms_wrapper import nms from utils.timer import Timer import matplotlib.pyplot as plt %matplotlib inline ROOT_DIR = os.getcwd() seed = 0 cudnn.benchmark = False cudnn.deterministic = True torch.manual_seed(seed) # 为CPU设置随机种子 torch.cuda.manual_seed_all(seed) # 为所有GPU设置随机种子 random.seed(seed) np.random.seed(seed) os.environ['PYTHONHASHSEED'] = str(seed) # 设置hash随机种子3.查看训练数据样例def read_xml(xml_path): '''读取xml标签''' tree = ET.parse(xml_path) root = tree.getroot() boxes = [] labels = [] for element in root.findall('object'): label = element.find('name').text if label == 'steel': bndbox = element.find('bndbox') xmin = bndbox.find('xmin').text ymin = bndbox.find('ymin').text xmax = bndbox.find('xmax').text ymax = bndbox.find('ymax').text boxes.append([xmin, ymin, xmax, ymax]) labels.append(label) return np.array(boxes, dtype=np.float64), labels4.显示原图和标注框train_img_dir = './rebar_count/datasets/VOC2007/JPEGImages' train_xml_dir = './rebar_count/datasets/VOC2007/Annotations' files = os.listdir(train_img_dir) files.sort() for index, file_name in enumerate(files[:2]): img_path = os.path.join(train_img_dir, file_name) xml_path = os.path.join(train_xml_dir, file_name.split('.jpg')[0] + '.xml') boxes, labels = read_xml(xml_path) img = Image.open(img_path) resize_scale = 2048.0 / max(img.size) img = img.resize((int(img.size[0] * resize_scale), int(img.size[1] * resize_scale))) boxes *= resize_scale plt.figure(figsize=(img.size[0]/100.0, img.size[1]/100.0)) plt.subplot(2,1,1) plt.imshow(img) img = img.convert('RGB') img = np.array(img) img = img.copy() for box in boxes: xmin, ymin, xmax, ymax = box.astype(np.int) cv2.rectangle(img, (xmin, ymin), (xmax, ymax), (0, 255, 0), thickness=3) plt.subplot(2,1,2) plt.imshow(img) plt.show()5.定义训练超参，模型、日志保存路径# 定义训练超参 num_classes = 2 # 数据集中只有 steel 一个标签，加上背景，所以总共有2个类 max_epoch = 25 # 默认值为1，调整为大于20的值，训练效果更佳 batch_size = 4 ngpu = 1 initial_lr = 0.01 img_dim = 416 # 模型输入图片大小 train_sets = [('2007', 'trainval')] # 指定训练集 cfg = VOC_Config rgb_means = (104, 117, 123) # ImageNet数据集的RGB均值 save_folder = './rebar_count/model_snapshots' # 指定训练模型保存路径 if not os.path.exists(save_folder): os.mkdir(save_folder) log_path = os.path.join('./rebar_count/logs', datetime.now().isoformat()) # 指定日志保存路径 if not os.path.exists(log_path): os.makedirs(log_path)6.构建模型，定义优化器及损失函数net = build_net('train', img_dim, num_classes=num_classes) if ngpu > 1: net = torch.nn.DataParallel(net) net.cuda() # 本案例代码只能在GPU上训练 cudnn.benchmark = True optimizer = optim.SGD(net.parameters(), lr=initial_lr, momentum=0.9, weight_decay=0) # 定义优化器 criterion = MultiBoxLoss(num_classes, overlap_thresh=0.4, prior_for_matching=True, bkg_label=0, neg_mining=True, neg_pos=3, neg_overlap=0.3, encode_target=False) # 定义损失函数 priorbox = PriorBox(cfg) with torch.no_grad(): priors = priorbox.forward() priors = priors.cuda()7.定义自适应学习率函数def adjust_learning_rate(optimizer, gamma, epoch, step_index, iteration, epoch_size): """ 自适应学习率 """ if epoch < 11: lr = 1e-8 + (initial_lr-1e-8) * iteration / (epoch_size * 10) else: lr = initial_lr * (gamma ** (step_index)) for param_group in optimizer.param_groups: param_group['lr'] = lr return lr8.定义训练函数def train(): """ 模型训练函数，每10次迭代打印一次日志，20个epoch之后，每个epoch保存一次模型 """ net.train() loc_loss = 0 conf_loss = 0 epoch = 0 print('Loading dataset...') dataset = VOCDetection(VOCroot, train_sets, preproc(img_dim, rgb_means, p=0.0), AnnotationTransform()) epoch_size = len(dataset) // batch_size max_iter = max_epoch * epoch_size stepvalues = (25 * epoch_size, 35 * epoch_size) step_index = 0 start_iter = 0 lr = initial_lr for iteration in range(start_iter, max_iter): if iteration % epoch_size == 0: if epoch > 20: torch.save(net.state_dict(), os.path.join(save_folder, 'epoch_' + repr(epoch).zfill(3) + '_loss_'+ '%.4f' % loss.item() + '.pth')) batch_iterator = iter(data.DataLoader(dataset, batch_size, shuffle=True, num_workers=1, collate_fn=detection_collate)) loc_loss = 0 conf_loss = 0 epoch += 1 load_t0 = time.time() if iteration in stepvalues: step_index += 1 lr = adjust_learning_rate(optimizer, 0.2, epoch, step_index, iteration, epoch_size) images, targets = next(batch_iterator) images = Variable(images.cuda()) targets = [Variable(anno.cuda()) for anno in targets] # forward t0 = time.time() out = net(images) # backprop optimizer.zero_grad() loss_l, loss_c = criterion(out, priors, targets) loss = loss_l + loss_c loss.backward() optimizer.step() t1 = time.time() loc_loss += loss_l.item() conf_loss += loss_c.item() load_t1 = time.time() if iteration % 10 == 0: print('Epoch:' + repr(epoch) + ' || epochiter: ' + repr(iteration % epoch_size) + '/' + repr(epoch_size) + '|| Totel iter ' + repr(iteration) + ' || L: %.4f C: %.4f||' % ( loss_l.item(),loss_c.item()) + 'Batch time: %.4f sec. ||' % (load_t1 - load_t0) + 'LR: %.8f' % (lr)) torch.save(net.state_dict(), os.path.join(save_folder, 'epoch_' + repr(epoch).zfill(3) + '_loss_'+ '%.4f' % loss.item() + '.pth'))9.开始训练，每个epoch训练耗时约60秒t1 = time.time() print('开始训练，本次训练总共需%d个epoch，每个epoch训练耗时约60秒' % max_epoch) train() print('training cost %.2f s' % (time.time() - t1))开始训练，本次训练总共需25个epoch，每个epoch训练耗时约60秒 Loading dataset... Epoch:1 || epochiter: 0/50|| Totel iter 0 || L: 3.7043 C: 3.7730||Batch time: 2.6931 sec. ||LR: 0.00000001 Epoch:1 || epochiter: 10/50|| Totel iter 10 || L: 3.1277 C: 3.1485||Batch time: 1.3692 sec. ||LR: 0.00020001 Epoch:1 || epochiter: 20/50|| Totel iter 20 || L: 3.3249 C: 2.4864||Batch time: 0.7837 sec. ||LR: 0.00040001 Epoch:1 || epochiter: 30/50|| Totel iter 30 || L: 2.8867 C: 2.4690||Batch time: 1.5246 sec. ||LR: 0.00060001 Epoch:1 || epochiter: 40/50|| Totel iter 40 || L: 2.6481 C: 2.1631||Batch time: 1.4777 sec. ||LR: 0.00080001 Epoch:2 || epochiter: 0/50|| Totel iter 50 || L: 3.0177 C: 2.1672||Batch time: 1.5618 sec. ||LR: 0.00100001 Epoch:2 || epochiter: 10/50|| Totel iter 60 || L: 1.9024 C: 1.8743||Batch time: 1.2920 sec. ||LR: 0.00120001 Epoch:2 || epochiter: 20/50|| Totel iter 70 || L: 1.5299 C: 1.7229||Batch time: 1.3726 sec. ||LR: 0.00140001 Epoch:2 || epochiter: 30/50|| Totel iter 80 || L: 1.7592 C: 1.8066||Batch time: 0.9840 sec. ||LR: 0.00160001 Epoch:2 || epochiter: 40/50|| Totel iter 90 || L: 1.4430 C: 1.7445||Batch time: 1.5012 sec. ||LR: 0.00180001 Epoch:3 || epochiter: 0/50|| Totel iter 100 || L: 1.3402 C: 1.5614||Batch time: 1.3830 sec. ||LR: 0.00200001 Epoch:3 || epochiter: 10/50|| Totel iter 110 || L: 1.2771 C: 1.7149||Batch time: 1.4420 sec. ||LR: 0.00220001 Epoch:3 || epochiter: 20/50|| Totel iter 120 || L: 2.1052 C: 2.3860||Batch time: 1.0122 sec. ||LR: 0.00240001 Epoch:3 || epochiter: 30/50|| Totel iter 130 || L: 1.3969 C: 2.0087||Batch time: 1.2500 sec. ||LR: 0.00260001 Epoch:3 || epochiter: 40/50|| Totel iter 140 || L: 1.1426 C: 1.3518||Batch time: 1.3625 sec. ||LR: 0.00280001 Epoch:4 || epochiter: 0/50|| Totel iter 150 || L: 1.3851 C: 1.3837||Batch time: 1.3933 sec. ||LR: 0.00300001 Epoch:4 || epochiter: 10/50|| Totel iter 160 || L: 0.8790 C: 1.0304||Batch time: 1.0430 sec. ||LR: 0.00320001 Epoch:4 || epochiter: 20/50|| Totel iter 170 || L: 1.1230 C: 1.2439||Batch time: 1.0029 sec. ||LR: 0.00340001 Epoch:4 || epochiter: 30/50|| Totel iter 180 || L: 1.0097 C: 1.1061||Batch time: 1.5267 sec. ||LR: 0.00360001 Epoch:4 || epochiter: 40/50|| Totel iter 190 || L: 0.8008 C: 1.0768||Batch time: 1.1727 sec. ||LR: 0.00380001 Epoch:5 || epochiter: 0/50|| Totel iter 200 || L: 1.0015 C: 1.1481||Batch time: 1.3881 sec. ||LR: 0.00400001 Epoch:5 || epochiter: 10/50|| Totel iter 210 || L: 0.9171 C: 1.1305||Batch time: 1.2255 sec. ||LR: 0.00420001 Epoch:5 || epochiter: 20/50|| Totel iter 220 || L: 0.9460 C: 1.0200||Batch time: 1.0095 sec. ||LR: 0.00440001 Epoch:5 || epochiter: 30/50|| Totel iter 230 || L: 0.8780 C: 1.1776||Batch time: 1.3224 sec. ||LR: 0.00460001 Epoch:5 || epochiter: 40/50|| Totel iter 240 || L: 0.8082 C: 0.8878||Batch time: 1.0734 sec. ||LR: 0.00480001 Epoch:6 || epochiter: 0/50|| Totel iter 250 || L: 0.7907 C: 0.9508||Batch time: 1.2835 sec. ||LR: 0.00500001 Epoch:6 || epochiter: 10/50|| Totel iter 260 || L: 0.6690 C: 0.8685||Batch time: 1.4887 sec. ||LR: 0.00520000 Epoch:6 || epochiter: 20/50|| Totel iter 270 || L: 1.1006 C: 0.9525||Batch time: 1.3324 sec. ||LR: 0.00540000 Epoch:6 || epochiter: 30/50|| Totel iter 280 || L: 0.9483 C: 1.0393||Batch time: 1.3198 sec. ||LR: 0.00560000 Epoch:6 || epochiter: 40/50|| Totel iter 290 || L: 0.8986 C: 1.0833||Batch time: 1.3434 sec. ||LR: 0.00580000 Epoch:7 || epochiter: 0/50|| Totel iter 300 || L: 0.8187 C: 0.9676||Batch time: 1.4531 sec. ||LR: 0.00600000 Epoch:7 || epochiter: 10/50|| Totel iter 310 || L: 0.6827 C: 0.9837||Batch time: 0.9223 sec. ||LR: 0.00620000 Epoch:7 || epochiter: 20/50|| Totel iter 320 || L: 0.7325 C: 0.8995||Batch time: 0.9585 sec. ||LR: 0.00640000 Epoch:7 || epochiter: 30/50|| Totel iter 330 || L: 0.9895 C: 1.0482||Batch time: 1.2272 sec. ||LR: 0.00660000 Epoch:7 || epochiter: 40/50|| Totel iter 340 || L: 0.5824 C: 0.8616||Batch time: 1.1445 sec. ||LR: 0.00680000 Epoch:8 || epochiter: 0/50|| Totel iter 350 || L: 1.1853 C: 1.2745||Batch time: 1.5200 sec. ||LR: 0.00700000 Epoch:8 || epochiter: 10/50|| Totel iter 360 || L: 0.7265 C: 1.1777||Batch time: 0.7649 sec. ||LR: 0.00720000 Epoch:8 || epochiter: 20/50|| Totel iter 370 || L: 0.7457 C: 0.8613||Batch time: 1.5218 sec. ||LR: 0.00740000 Epoch:8 || epochiter: 30/50|| Totel iter 380 || L: 0.5295 C: 0.9103||Batch time: 1.2653 sec. ||LR: 0.00760000 Epoch:8 || epochiter: 40/50|| Totel iter 390 || L: 0.7083 C: 1.0060||Batch time: 1.1069 sec. ||LR: 0.00780000 Epoch:9 || epochiter: 0/50|| Totel iter 400 || L: 0.6398 C: 0.9866||Batch time: 1.5802 sec. ||LR: 0.00800000 Epoch:9 || epochiter: 10/50|| Totel iter 410 || L: 0.5987 C: 0.8167||Batch time: 1.0675 sec. ||LR: 0.00820000 Epoch:9 || epochiter: 20/50|| Totel iter 420 || L: 0.5751 C: 0.7944||Batch time: 0.7669 sec. ||LR: 0.00840000 Epoch:9 || epochiter: 30/50|| Totel iter 430 || L: 0.7229 C: 1.0396||Batch time: 1.3895 sec. ||LR: 0.00860000 Epoch:9 || epochiter: 40/50|| Totel iter 440 || L: 0.5569 C: 0.9122||Batch time: 0.8300 sec. ||LR: 0.00880000 Epoch:10 || epochiter: 0/50|| Totel iter 450 || L: 0.6908 C: 0.9928||Batch time: 1.4029 sec. ||LR: 0.00900000 Epoch:10 || epochiter: 10/50|| Totel iter 460 || L: 0.6851 C: 0.8068||Batch time: 1.2804 sec. ||LR: 0.00920000 Epoch:10 || epochiter: 20/50|| Totel iter 470 || L: 0.6783 C: 0.8511||Batch time: 1.7469 sec. ||LR: 0.00940000 Epoch:10 || epochiter: 30/50|| Totel iter 480 || L: 0.7962 C: 0.8040||Batch time: 1.6116 sec. ||LR: 0.00960000 Epoch:10 || epochiter: 40/50|| Totel iter 490 || L: 0.7782 C: 0.9469||Batch time: 1.1979 sec. ||LR: 0.00980000 Epoch:11 || epochiter: 0/50|| Totel iter 500 || L: 0.8902 C: 0.8956||Batch time: 1.8625 sec. ||LR: 0.01000000 Epoch:11 || epochiter: 10/50|| Totel iter 510 || L: 0.8532 C: 0.9259||Batch time: 1.2692 sec. ||LR: 0.01000000 Epoch:11 || epochiter: 20/50|| Totel iter 520 || L: 0.7917 C: 0.7990||Batch time: 1.7494 sec. ||LR: 0.01000000 Epoch:11 || epochiter: 30/50|| Totel iter 530 || L: 0.9688 C: 1.2376||Batch time: 1.1547 sec. ||LR: 0.01000000 Epoch:11 || epochiter: 40/50|| Totel iter 540 || L: 0.7030 C: 0.8440||Batch time: 1.1588 sec. ||LR: 0.01000000 Epoch:12 || epochiter: 0/50|| Totel iter 550 || L: 0.6580 C: 0.8380||Batch time: 1.2196 sec. ||LR: 0.01000000 Epoch:12 || epochiter: 10/50|| Totel iter 560 || L: 0.7978 C: 0.8454||Batch time: 1.1011 sec. ||LR: 0.01000000 Epoch:12 || epochiter: 20/50|| Totel iter 570 || L: 0.6071 C: 0.8394||Batch time: 0.7146 sec. ||LR: 0.01000000 Epoch:12 || epochiter: 30/50|| Totel iter 580 || L: 0.4787 C: 0.6888||Batch time: 1.2482 sec. ||LR: 0.01000000 Epoch:12 || epochiter: 40/50|| Totel iter 590 || L: 0.6505 C: 0.8412||Batch time: 1.1304 sec. ||LR: 0.01000000 Epoch:13 || epochiter: 0/50|| Totel iter 600 || L: 0.6316 C: 0.8319||Batch time: 1.4268 sec. ||LR: 0.01000000 Epoch:13 || epochiter: 10/50|| Totel iter 610 || L: 0.6693 C: 0.7822||Batch time: 1.2204 sec. ||LR: 0.01000000 Epoch:13 || epochiter: 20/50|| Totel iter 620 || L: 0.6773 C: 0.9631||Batch time: 1.2477 sec. ||LR: 0.01000000 Epoch:13 || epochiter: 30/50|| Totel iter 630 || L: 0.4851 C: 0.8346||Batch time: 1.2228 sec. ||LR: 0.01000000 Epoch:13 || epochiter: 40/50|| Totel iter 640 || L: 0.7247 C: 0.9392||Batch time: 1.2318 sec. ||LR: 0.01000000 Epoch:14 || epochiter: 0/50|| Totel iter 650 || L: 0.5716 C: 0.7683||Batch time: 1.8367 sec. ||LR: 0.01000000 Epoch:14 || epochiter: 10/50|| Totel iter 660 || L: 0.7804 C: 1.0285||Batch time: 1.0683 sec. ||LR: 0.01000000 Epoch:14 || epochiter: 20/50|| Totel iter 670 || L: 0.4620 C: 0.8179||Batch time: 1.3811 sec. ||LR: 0.01000000 Epoch:14 || epochiter: 30/50|| Totel iter 680 || L: 0.5459 C: 0.7611||Batch time: 1.4473 sec. ||LR: 0.01000000 Epoch:14 || epochiter: 40/50|| Totel iter 690 || L: 0.4946 C: 0.7604||Batch time: 1.2968 sec. ||LR: 0.01000000 Epoch:15 || epochiter: 0/50|| Totel iter 700 || L: 0.6467 C: 0.6637||Batch time: 1.4271 sec. ||LR: 0.01000000 Epoch:15 || epochiter: 10/50|| Totel iter 710 || L: 0.4383 C: 0.6140||Batch time: 1.1232 sec. ||LR: 0.01000000 Epoch:15 || epochiter: 20/50|| Totel iter 720 || L: 0.5551 C: 0.9027||Batch time: 1.2992 sec. ||LR: 0.01000000 Epoch:15 || epochiter: 30/50|| Totel iter 730 || L: 0.4488 C: 0.7574||Batch time: 0.9148 sec. ||LR: 0.01000000 Epoch:15 || epochiter: 40/50|| Totel iter 740 || L: 0.5179 C: 0.6202||Batch time: 1.5350 sec. ||LR: 0.01000000 Epoch:16 || epochiter: 0/50|| Totel iter 750 || L: 0.4956 C: 0.6740||Batch time: 1.6760 sec. ||LR: 0.01000000 Epoch:16 || epochiter: 10/50|| Totel iter 760 || L: 0.5780 C: 0.8834||Batch time: 1.3318 sec. ||LR: 0.01000000 Epoch:16 || epochiter: 20/50|| Totel iter 770 || L: 0.5829 C: 0.7340||Batch time: 1.0279 sec. ||LR: 0.01000000 Epoch:16 || epochiter: 30/50|| Totel iter 780 || L: 0.4798 C: 0.7019||Batch time: 1.4545 sec. ||LR: 0.01000000 Epoch:16 || epochiter: 40/50|| Totel iter 790 || L: 0.6511 C: 0.7712||Batch time: 1.7330 sec. ||LR: 0.01000000 Epoch:17 || epochiter: 0/50|| Totel iter 800 || L: 0.4281 C: 0.6578||Batch time: 1.6699 sec. ||LR: 0.01000000 Epoch:17 || epochiter: 10/50|| Totel iter 810 || L: 0.5440 C: 0.7102||Batch time: 1.4820 sec. ||LR: 0.01000000 Epoch:17 || epochiter: 20/50|| Totel iter 820 || L: 0.4770 C: 0.7014||Batch time: 1.4020 sec. ||LR: 0.01000000 Epoch:17 || epochiter: 30/50|| Totel iter 830 || L: 0.3601 C: 0.5890||Batch time: 1.0758 sec. ||LR: 0.01000000 Epoch:17 || epochiter: 40/50|| Totel iter 840 || L: 0.4817 C: 0.7329||Batch time: 1.3797 sec. ||LR: 0.01000000 Epoch:18 || epochiter: 0/50|| Totel iter 850 || L: 0.4860 C: 0.7499||Batch time: 1.3214 sec. ||LR: 0.01000000 Epoch:18 || epochiter: 10/50|| Totel iter 860 || L: 0.6856 C: 0.7154||Batch time: 1.4014 sec. ||LR: 0.01000000 Epoch:18 || epochiter: 20/50|| Totel iter 870 || L: 0.6231 C: 0.7692||Batch time: 0.9905 sec. ||LR: 0.01000000 Epoch:18 || epochiter: 30/50|| Totel iter 880 || L: 0.6680 C: 0.8625||Batch time: 1.1373 sec. ||LR: 0.01000000 Epoch:18 || epochiter: 40/50|| Totel iter 890 || L: 0.5535 C: 0.7393||Batch time: 1.1122 sec. ||LR: 0.01000000 Epoch:19 || epochiter: 0/50|| Totel iter 900 || L: 0.4691 C: 0.7235||Batch time: 1.3488 sec. ||LR: 0.01000000 Epoch:19 || epochiter: 10/50|| Totel iter 910 || L: 0.6145 C: 0.7811||Batch time: 1.1163 sec. ||LR: 0.01000000 Epoch:19 || epochiter: 20/50|| Totel iter 920 || L: 0.4698 C: 0.7225||Batch time: 1.6120 sec. ||LR: 0.01000000 Epoch:19 || epochiter: 30/50|| Totel iter 930 || L: 0.5623 C: 0.7341||Batch time: 1.3949 sec. ||LR: 0.01000000 Epoch:19 || epochiter: 40/50|| Totel iter 940 || L: 0.4859 C: 0.5786||Batch time: 0.8949 sec. ||LR: 0.01000000 Epoch:20 || epochiter: 0/50|| Totel iter 950 || L: 0.4193 C: 0.6898||Batch time: 1.4702 sec. ||LR: 0.01000000 Epoch:20 || epochiter: 10/50|| Totel iter 960 || L: 0.4434 C: 0.6261||Batch time: 1.0974 sec. ||LR: 0.01000000 Epoch:20 || epochiter: 20/50|| Totel iter 970 || L: 0.5948 C: 0.8787||Batch time: 1.1951 sec. ||LR: 0.01000000 Epoch:20 || epochiter: 30/50|| Totel iter 980 || L: 0.5842 C: 0.6120||Batch time: 0.9863 sec. ||LR: 0.01000000 Epoch:20 || epochiter: 40/50|| Totel iter 990 || L: 0.4010 C: 0.7356||Batch time: 1.5981 sec. ||LR: 0.01000000 Epoch:21 || epochiter: 0/50|| Totel iter 1000 || L: 0.4719 C: 0.6351||Batch time: 1.1228 sec. ||LR: 0.01000000 Epoch:21 || epochiter: 10/50|| Totel iter 1010 || L: 0.5856 C: 0.7444||Batch time: 1.3812 sec. ||LR: 0.01000000 Epoch:21 || epochiter: 20/50|| Totel iter 1020 || L: 0.5810 C: 0.8371||Batch time: 1.2560 sec. ||LR: 0.01000000 Epoch:21 || epochiter: 30/50|| Totel iter 1030 || L: 0.4583 C: 0.9570||Batch time: 1.1499 sec. ||LR: 0.01000000 Epoch:21 || epochiter: 40/50|| Totel iter 1040 || L: 0.5411 C: 0.5317||Batch time: 1.4007 sec. ||LR: 0.01000000 Epoch:22 || epochiter: 0/50|| Totel iter 1050 || L: 0.3508 C: 0.5599||Batch time: 1.1371 sec. ||LR: 0.01000000 Epoch:22 || epochiter: 10/50|| Totel iter 1060 || L: 0.4045 C: 0.6965||Batch time: 1.1030 sec. ||LR: 0.01000000 Epoch:22 || epochiter: 20/50|| Totel iter 1070 || L: 0.3949 C: 0.6019||Batch time: 1.4505 sec. ||LR: 0.01000000 Epoch:22 || epochiter: 30/50|| Totel iter 1080 || L: 0.3467 C: 0.5563||Batch time: 1.1956 sec. ||LR: 0.01000000 Epoch:22 || epochiter: 40/50|| Totel iter 1090 || L: 0.5757 C: 0.5643||Batch time: 0.8669 sec. ||LR: 0.01000000 Epoch:23 || epochiter: 0/50|| Totel iter 1100 || L: 0.3946 C: 0.6081||Batch time: 1.7117 sec. ||LR: 0.01000000 Epoch:23 || epochiter: 10/50|| Totel iter 1110 || L: 0.3655 C: 0.5579||Batch time: 0.9830 sec. ||LR: 0.01000000 Epoch:23 || epochiter: 20/50|| Totel iter 1120 || L: 0.3912 C: 0.6437||Batch time: 1.2725 sec. ||LR: 0.01000000 Epoch:23 || epochiter: 30/50|| Totel iter 1130 || L: 0.4237 C: 0.6337||Batch time: 1.3346 sec. ||LR: 0.01000000 Epoch:23 || epochiter: 40/50|| Totel iter 1140 || L: 0.3474 C: 0.5517||Batch time: 1.1646 sec. ||LR: 0.01000000 Epoch:24 || epochiter: 0/50|| Totel iter 1150 || L: 0.5573 C: 0.7426||Batch time: 1.5291 sec. ||LR: 0.01000000 Epoch:24 || epochiter: 10/50|| Totel iter 1160 || L: 0.6122 C: 0.6805||Batch time: 1.1861 sec. ||LR: 0.01000000 Epoch:24 || epochiter: 20/50|| Totel iter 1170 || L: 0.3846 C: 0.6484||Batch time: 1.2575 sec. ||LR: 0.01000000 Epoch:24 || epochiter: 30/50|| Totel iter 1180 || L: 0.4183 C: 0.6982||Batch time: 1.1318 sec. ||LR: 0.01000000 Epoch:24 || epochiter: 40/50|| Totel iter 1190 || L: 0.5259 C: 0.7322||Batch time: 1.0091 sec. ||LR: 0.01000000 Epoch:25 || epochiter: 0/50|| Totel iter 1200 || L: 0.4047 C: 0.5544||Batch time: 1.4809 sec. ||LR: 0.01000000 Epoch:25 || epochiter: 10/50|| Totel iter 1210 || L: 0.4519 C: 0.5351||Batch time: 1.2974 sec. ||LR: 0.01000000 Epoch:25 || epochiter: 20/50|| Totel iter 1220 || L: 0.4390 C: 0.6232||Batch time: 1.0032 sec. ||LR: 0.01000000 Epoch:25 || epochiter: 30/50|| Totel iter 1230 || L: 0.4840 C: 0.7323||Batch time: 1.0048 sec. ||LR: 0.01000000 Epoch:25 || epochiter: 40/50|| Totel iter 1240 || L: 0.6699 C: 0.8887||Batch time: 1.7034 sec. ||LR: 0.01000000 training cost 1572.48 s10.已完成训练，下面开始测试模型，首先需定义目标检测类cfg = VOC_Config img_dim = 416 rgb_means = (104, 117, 123) priorbox = PriorBox(cfg) with torch.no_grad(): priors = priorbox.forward() if torch.cuda.is_available(): priors = priors.cuda() class ObjectDetector: """ 定义目标检测类 """ def __init__(self, net, detection, transform, num_classes=num_classes, thresh=0.01, cuda=True): self.net = net self.detection = detection self.transform = transform self.num_classes = num_classes self.thresh = thresh self.cuda = torch.cuda.is_available() def predict(self, img): _t = {'im_detect': Timer(), 'misc': Timer()} scale = torch.Tensor([img.shape[1], img.shape[0], img.shape[1], img.shape[0]]) with torch.no_grad(): x = self.transform(img).unsqueeze(0) if self.cuda: x = x.cuda() scale = scale.cuda() _t['im_detect'].tic() out = net(x) # forward pass boxes, scores = self.detection.forward(out, priors) detect_time = _t['im_detect'].toc() boxes = boxes[0] scores = scores[0] # scale each detection back up to the image boxes *= scale boxes = boxes.cpu().numpy() scores = scores.cpu().numpy() _t['misc'].tic() all_boxes = [[] for _ in range(num_classes)] for j in range(1, num_classes): inds = np.where(scores[:, j] > self.thresh)[0] if len(inds) == 0: all_boxes[j] = np.zeros([0, 5], dtype=np.float32) continue c_bboxes = boxes[inds] c_scores = scores[inds, j] c_dets = np.hstack((c_bboxes, c_scores[:, np.newaxis])).astype( np.float32, copy=False) keep = nms(c_dets, 0.2, force_cpu=False) c_dets = c_dets[keep, :] all_boxes[j] = c_dets nms_time = _t['misc'].toc() total_time = detect_time + nms_time return all_boxes, total_time11.定义推理网络，并加载前面训练的loss最低的模型trained_models = os.listdir(os.path.join(ROOT_DIR, './rebar_count/model_snapshots')) # 模型文件所在目录 lowest_loss = 9999 best_model_name = '' for model_name in trained_models: if not model_name.endswith('pth'): continue loss = float(model_name.split('_loss_')[1].split('.pth')[0]) if loss < lowest_loss: lowest_loss = loss best_model_name = model_name best_model_path = os.path.join(ROOT_DIR, './rebar_count/model_snapshots', best_model_name) print('loading model from', best_model_path) net = build_net('test', img_dim, num_classes) # 加载模型 state_dict = torch.load(best_model_path) new_state_dict = OrderedDict() for k, v in state_dict.items(): head = k[:7] if head == 'module.': name = k[7:] else: name = k new_state_dict[name] = v net.load_state_dict(new_state_dict) net.eval() print('Finish load model!') if torch.cuda.is_available(): net = net.cuda() cudnn.benchmark = True else: net = net.cpu() detector = Detect(num_classes, 0, cfg) transform = BaseTransform(img_dim, rgb_means, (2, 0, 1)) object_detector = ObjectDetector(net, detector, transform)loading model from /home/ma-user/work/./rebar_count/model_snapshots/epoch_023_loss_1.0207.pth Finish load model!12.测试图片，输出每条钢筋的位置和图片中钢筋总条数test_img_dir = r'./rebar_count/datasets/test_dataset' # 待预测的图片目录 files = os.listdir(test_img_dir) files.sort() for i, file_name in enumerate(files[:2]): image_src = cv2.imread(os.path.join(test_img_dir, file_name)) detect_bboxes, tim = object_detector.predict(image_src) image_draw = image_src.copy() rebar_count = 0 for class_id, class_collection in enumerate(detect_bboxes): if len(class_collection) > 0: for i in range(class_collection.shape[0]): if class_collection[i, -1] > 0.6: pt = class_collection[i] cv2.circle(image_draw, (int((pt[0] + pt[2]) * 0.5), int((pt[1] + pt[3]) * 0.5)), int((pt[2] - pt[0]) * 0.5 * 0.6), (255, 0, 0), -1) rebar_count += 1 cv2.putText(image_draw, 'rebar_count: %d' % rebar_count, (25, 50), cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 255, 0), 3) plt.figure(i, figsize=(30, 20)) plt.imshow(image_draw) plt.show()至此，本案例结束。