百度Apollo自动驾驶仿真平台9.0版本Perception模块相关内容

基于官方教程https://apollo.baidu.com/community/article/1186，根据实际使用增改部分内容。

1 Apollo Perception环境配置

1.1 安装基础软件

1.1.1 安装Linux - Ubuntu

Ubuntu系统安装完成请更新相关软件：

1

sudo apt-get update

1

sudo apt-get upgrade

1.1.2 安装 Docker Engine

Apollo 依赖于 Docker 19.03+。安装 Docker 引擎，您可以根据官方文档进行安装：

1

wget http://apollo-pkg-beta.bj.bcebos.com/docker_install.shbash docker_install.sh

1

bash docker_install.sh

注：1.1.1和1.1.2步骤安装过无需重复安装。

1.1.3 安装驱动

显卡驱动和CUDA版本兼容性，由于nvidia的硬件更新的很快，因此会遇到显卡驱动和CUDA版本不兼容的情况，以下为我们测试的畅通链路。

1.1.3.1 安装显卡驱动

10、20、30系列显卡推荐使用470.63.01版本，下载链接470.63.01显卡驱动

（实际使用时显卡驱动版本高于推荐也可正常使用，因此在安装系统时已将驱动安装好的话，则不用安装，再次安装会提示已安装驱动无法再次安装）：

1
2

#使用该命令查看是否安装显卡，若出现下述“驱动检查”所示图内容，则已安装显卡驱动，否则执行下面指令安装
nvidia-smi

下载之后，找到相应的文件夹打开终端输入指令：

1

sudo chmod 777 NVIDIA-Linux-x86_64-470.63.01.runsudo ./NVIDIA-Linux-x86_64-470.63.01.run

驱动检查

1

nvidia-smi

https://apollo-studio-public.bj.bcebos.com/community/article/image/9ae7ced2c94a36b08552b43487a260a83589a428

注：如若出现以下情况，则说明没有下载显卡驱动https://apollo.baidu.com/community/article/1181

https://apollo-studio-public.bj.bcebos.com/community/article/image/93433bba9bac0293fd6df871083ad0f8157ef648

注：本教程只适用于ubuntu系统，虚拟机无法安装显卡驱动

1.1.3.2 安装nvida-docker

为了在容器内获得 GPU 支持，在安装完 docker 后需要安装 NVIDIA Container Toolkit。 运行以下指令安装 NVIDIA Container Toolkit：（实际使用时会出现报错：无法定位软件包 nvidia-docker2）

1

distribution=$(. /etc/os-release;echo $ID$VERSION_ID) curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add - curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list sudo apt-get -y update sudo apt-get install -y nvidia-docker2

注：如果上面方法报错，则使用官方方法nvida-docker官方教程，执行下面图片中的两条指令：

1.2 安装 Apollo 环境管理工具

1.2.1 基础环境准备

1
2
3
4
5
6
7
8

# 添加访问认证
wget -O - https://apollo-pkg-beta.cdn.bcebos.com/neo/beta/key/deb.gpg.key | sudo apt-key add -

# Apollo -alpha 版源地址
sudo bash -c "echo 'deb https://apollo-pkg-beta.cdn.bcebos.com/apollo/core bionic main' >> /etc/apt/sources.list.d/apolloauto.list"

# 更新源
sudo apt update

1.2.2 安装 aem工具

如果没有安装过apollo 8.0aem，使用以下命令直接安装：

1

sudo apt install apollo-neo-env-manager-dev

安装成功后，可以使用以下查看安装是否成功，出现下图所示即为成功：

1

aem -h

1.3 下载 Perception工程

1.3.1 下载工程代码

1

git clone https://github.com/ApolloAuto/application-perception

注：如果出现⽆法访问等问题，可使⽤以下⽅法：

1

git clone [https://gitee.com/ApolloAuto/application-perception](https://gitee.com/ApolloAuto/application-perception)

1.3.2 进入工程目录

1

cd application-perception

1
2

#检查目录，只是看一下文件结构，并未有数据操作，如下显示"9.0.0-alpha2-r31"即为正确
cat .workspace.json

https://apollo-studio-public.bj.bcebos.com/community/article/image/4ef69657ff72bed3ab517a35535554d762d1cf47

注：如若显示“9.0.0-alpha2-r29”：

1
2

#请使用：
git pull

或手动更改.workspace.json文件的9.0.0-alpha2-r29为9.0.0-alpha2-r31

再使用cat .workspace.json 指令查看是否已更改

https://apollo-studio-public.bj.bcebos.com/community/article/image/4ef69657ff72bed3ab517a35535554d762d1cf47

1.4 调试perception工程

1.4.1 进入Docker环境

1
2
3
4
5

# 拉取并启动docker容器
aem start

# 进入容器
aem enter

注：在输入aem start后终端应为下图所示

若仍然出现下图所示warning，则1.1.3.2 安装nvida-docker失败

检查buildtool版本

1

buildtool -v

注：如若buildtool版本与上图不一致，即以9.0.0-alpha开头的版本，请使用以下指令更新：

1

sudo apt update && sudo apt install --only-upgrade apollo-neo-buildtool

升级aem工具

1

sudo apt install apollo-neo-env-manager-dev

安装依赖包

会拉取安装core目录下的cyberfile.xml里面所有的依赖包

1

buildtool build --gpu

注：该工程中只有感知功能，如若想添加PnC（planning规划）功能请参考如下链接（可选）

请参考文章中的1.1.5升级CCF- BDCI赛事复赛工程https://apollo.baidu.com/community/article/1180

另外：安装的planning等模块的源码会保存到工程文件的modules文件夹中，如果安装后并未出现，可参考application-perception/core/cyberfile.xml文件中的内容进行安装，具体使用如下：

1

buildtool install xxx

其中xxx为想要安装的模块名称，例如要安装planning的源码，可查阅cyberfile.xml文件，可知其repo_name为”planning”：

则安装命令相应为：

1

buildtool install planning

执行后在application-perception/modules文件夹内会出现planning源码文件夹：

1.4.2 设置车型参数

本次赛事用的是apolloscape数据集，车型参数设置为apolloscape参数。

1

aem profile use apolloscape

1.4.3 启动Dreamview+

1

aem bootstrap start --plus

plus参数指的是启动dreamview+。

1.4.4 下载安装感知模型

安装amodel模型管理工具：

1
2

wget https://apollo-pkg-beta.cdn.bcebos.com/perception/amodel-0.2.0.tar.gz
pip3 install --user amodel-0.2.0.tar.gz

导入环境变量：

1

export PATH=~/.local/bin/:$PATH

安装感知模型：

1

sudo ~/.local/bin/amodel install center_point_paddle

安装完后使用命令查看安装的模型：

1

amodel list

1.4.5 启动lidar感知程序，播包调试(该步骤用于播放record，安装时不用执行)

启动lidar感知有两个方法，以下两个方法选择一个。

1.4.5.1 Dreamview+ 启动

在1.4.3启动Dreamview后，点击左侧Mode Settings按钮，Mode选择Perception：

启动Transform、Lidar感知模块：

1.4.5.2 命令行启动（一般用Dreamview+ 启动即可）

启动transform：

1

cyber_launch start /apollo/modules/transform/launch/static_transform.launch

启动lidar感知：

1

cyber_launch start /apollo/modules/perception/lidar_output/launch/lidar_output.launch

1.4.5.3 播包调试感知

在Dreamview观察感知情况。record包的生产参考下面的数据准备部分：

1
2

# xxx.record是具体record的名称
cyber_recorder play -f xxx.record

2 数据准备

2.1 数据下载

训练集、测试集和脚本代码中分别有readme说明。

一共需要下载下面三个文件，其中前两个大小都在13G左右，需要有足够空间。

点击下表中的链接会在浏览器直接创建下载任务，不过速度很慢。

推荐将下方链接复制，然后在windows中使用迅雷新建下载任务，填入复制的链接下载，或者找我拷贝。

注注注：官方还推出了使用百度ai studio进行训练的教程，如果内存不足，则不要下载，可以参考此链接：https://apollo.baidu.com/community/article/1184

（分数榜单使用的数据集） |
| 3 | 脚本代码 | https://apollo-records.bj.bcebos.com/perception/apolloscape/apolloscape_scripts.zip?authorization=bce-auth-v1/0824ae9513f643518e120667fc2a6d50/2023-11-13T11%3A32%3A35Z/2592000/host/e662b3c0219eeaa374ecbec0e024c9f71e1b7925de9d06a79c6506b035f466f6 | 将ApolloScape数据集转换为KITTI数据集的脚本
将ApolloScape数据转换为record的脚本 |

2.2 adataset环境配置

adataset用于将apolloscape数据转化为apollo record格式，方便做端到端感知调试。

1
2

# 在application-perception目录下进入到容器内。如果已经在容器内，则不需要执行。
aem enter

安装adataset：

1
2
3
4
5
6
7
8

# 更新pip源
pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/

# 升级pip
python -m pip install --upgrade setuptools

# 安装adataset
pip install adataset

2.3 数据转化

下载的三个文件为三个压缩包，各自包含内容如下：

我们可以将压缩包里的三个文件提取到同一个文件夹 apolloDataSet 内：

在脚本代码scripts文件夹内中有apolloscape_to_records.py和apolloscape_to_kitti.py，即下面命令所用到的两个程序。

同时我们需要提前创建两个空文件夹train_records，kitti，用于存放下面转换的数据：

2.3.1 使用apolloscape_to_records.py将apolloscape转化成apollo records数据（需要在 apolloDataSet 文件夹打开终端）：

1
2
3
4

 # -d表示apolloscape数据集。用a就好； 
# -i表示数据数据集。这里目录就用训练集和测试集的目录； 
# -o输出目录。注意：目录要提前创建好（上面内容已提示过）； # -t类型。用rcd就好。 
python scripts/apolloscape_to_records.py -d=a -i=train/ -o=train_records/ -t=rcd

注：如果报错ModuleNotFoundError: No module named ‘yaml’，执行下面命令安装后重新运行上面代码即可：

1

pip install pyyaml

2.3.2 Python2环境安装

（1）安装miniconda（anaconda的轻量版）

官网：https://docs.conda.io/projects/miniconda/en/latest/miniconda-install.html

或者参考我的教程：https://yang-makabaka.github.io/posts/4120ac2f.html

（2）使用conda创建环境

• 创建python2环境：

1

conda create -n python2 python=2.7

• 切换到python2环境：

1
2

conda activate python2
#报错的话，用 source activate python2

• 安装pypcd和numpy：

  1 2 3

  conda install numpy pip install pypcd

• 然后就可以使用下面命令将apolloscape数据集转化成kitti格式。

2.3.3 使用apolloscape_to_kitti.py将apolloscape数据转化kitti格式，用于训练centerpoint模型（需要在 apolloDataSet 文件夹打开终端，且进入上面创建的环境python2）：

1
2
3
4
5

#注：此步骤可在本地环境操作，不需要在容器中。本地需要具备pypcd库、numpy库和python2环境。
# --pcd_path: 点云数据路径，这里用的是pcl_pcd；
# --label_path: 标注结果。这里用的是detection_label；
# --output_path: 存放生成的数据，包括点云和标注两部分。
python2 scripts/apolloscape_to_kitti.py --pcd_path=train/pcl_pcd/ --label_path=train/detection_label/ --output_path=./kitti

百度Apollo自动驾驶仿真平台9.0版本Planning模块相关内容

概述

1 运行流程

如下图所示，Planning模块的上游是Localization, Prediction, Routing模块，而下游是Control模块。Routing模块先规划出一条导航线路，然后Planning模块根据这条线路做局部优化，如果Planning模块发现短期规划的线路行不通（比如前面修路，或者错过了路口），会触发Routing模块重新规划线路，因此这两个模块的数据流是双向的。

2 原理

Apollo 规划模块功能的实现是基于场景（scenario-based）实现的，针对不同的场景，规划模块通过一系列独立的 任务（task） 组合来完成轨迹的规划。开发者可以根据自己的使用需求，调整支持运行的场景列表，或者场景中支持的任务类型来满足自己的需求。

Apollo 规划架构示意图如上，其中部分重要模块如下：

• 状态机（Apollo FSM（Finite State Machine））：一个有限状态机，结合导航、环境等信息确定自动驾驶车辆的驾驶场景
• 规划分发器（Planning Dispatcher）：根据状态机与车辆相关信息，调用合适当前场景的规划器
• 规划器（Planner）：结合上游模块信息，通过一系列的任务组合，完成自动驾驶车辆的轨迹规划
• 决策器 & 优化器（Deciders & Optimizers）：一组实现决策和优化任务的 task 集合。优化器用于优化车辆的轨迹和速度。决策器则基于规则，确定自动驾驶车辆何时换车道、何时停车、何时蠕行（慢速行进）或蠕行何时完成等驾驶行为。

3 功能列表

4 最新9.0更新特性

（1）接口升级

在新版本中对这些接口进行了优化和升级：

• 统一梳理和封装，调用接口时，命令统一转发到”ExternalCommandProcessor”模块，通过封装，当PNC内部模块接口升级时，可以保持外部命令接口不变。
• 改用cyber中service-client机制调用，用户可以通过client查询当前任务的执行状态。
• 对RoutingRequest的导航命令做了精简：
  • 原来的导航命令需要查询地图，找到路由点和终点最近的车道，并得到在车道上对应的投影点；精简后的命令只需要给出坐标和朝向即可。
  • 发送导航命令不再需要发送车辆当前的位置作为起点位置，PNC会自动获取并处理起点位置。

升级后的命令数据流程如下图：

https://apollo-studio-public.bj.bcebos.com/community/article/image/d97beb0b78343b224bb30c5e58c5a8ee83692a58

升级前后命令功能保持不变，对照关系如下表所示：

升级后的接口有以下几个优点：

• 命令调用更清晰简便，新的导航接口精简了数据，用户只需要设置必要的坐标和朝向信息即可。
• 使用service/client的调用方式，新的接口可以通过client获取命令执行的状态，查看命令是正在执行中，已经完成或有错误发生。
• 新的接口支持用户自定义扩展自己的命令。

（2）插件化

插件是新版本中的支持用户灵活扩展新功能的一种方式，用户新扩展的插件符合父类程序接口规范，通过重写接口的实现来增加新的功能，插件以独立包的方式发布。

在planning中主要对scenario，task和traffic rules进行了插件化，用户可以根据场景需要，自定义添加自己的场景，任务或交通规则，具体插件添加的方式后续文档中有详细的介绍。

例如用户新增左转待转场景插件，增加一个包left_turn_waiting_zone，在这个包中添加左转待转场景的实现代码，以及相关的工程文件，编译调试后发布即可。

https://apollo-studio-public.bj.bcebos.com/community/article/image/3b6c4db95d33bc17735ecd063023099c41c9de11

需要运行这个场景时，在planning的配置文件中，添加这个场景的pipeline：

https://apollo-studio-public.bj.bcebos.com/community/article/image/68c3e9553caa9e10281a0231d408879592c7d56e

旧版本中不使用插件的方式，用户新增一个scenario，task，traffic rules，需要修改planning component流程代码，用于创建新的类型对象，添加新增对象的流程调用，修改proto文件等。这样的问题一个是修改处较多，修改过程繁琐；另外就是当用户在planning中增加了一个新的scenario，task，traffic rules时，后续apollo升级时，用户无法直接跟着升级，需要手动merge自己修改的代码。

使用插件的方式扩展scenario，task，traffic rules，可以实现：

• 用户根据自己的场景，使用包管理的方式，选择性下载安装自己需要的scenario，task，traffic rules即可。
• 用户新增的插件独立开发，编译，发布和运行。
• 用户新增了插件后，可以直接跟随apollo一起升级。

（3）参数配置升级

planning中的配置参数量较大，入门调试时难度较高，用户想要修改的功能对应的参数不直观，并且不易快速定位需要修改的参数位置。针对这些问题，对配置参数进行了以下调整：

• 将参数分成全局变量和局部变量，全局变量是多个算法或插件中共同使用的参数；局部变量是专属于某个算法或插件的参数。如果用户需要调整某个插件的参数，直接在插件的目录中查找。

planning的全部变量在planning/planning_base/conf目录下：

https://apollo-studio-public.bj.bcebos.com/community/article/image/41ccd3fd662882ffc3cae2d94992347e5cd7d7bb

planning的局部变量在插件自身的目录下，如lane_change_path这个Task插件的参数：

https://apollo-studio-public.bj.bcebos.com/community/article/image/2798392db33adc3c4a10f313e2b50887cefe8d00

添加对常用功能使用到的参数的说明文档，方便用户调试时查询。对参数目录进行重新梳理和作用范围的划分，有以下优点：

• 参数的目录跟随作用范围和功能，这样对参数的定位更清晰和直观。
• 用户新增的插件所使用的参数，可以跟随插件进行发布和管理。

百度Apollo自动驾驶仿真平台9.0版本Planning模块相关内容

场景介绍：主车在城市道路行驶时，行驶至交汇路口时需降低速度至5米/秒，并在过后恢复正常速度。

通过打开“Junction”显示按钮，得知该路口（下图中蓝色框内区域）为junction的道路类型。

1.新增 traffic rule 插件

按下面链接完成

https://apollo.baidu.com/community/article/1121

2.代码修改

（1）pnc_junction_overlaps改为junction_overlaps

modules/planning/traffic_rules/region_speed_limit/region_speed_limit.cc

1
2
3
4
5

原： const std::vector<PathOverlap> & pnc_junction_overlaps 
= reference_line_info-> reference_line ( ) . map_path ( ) . pnc_junction_overlaps ( ) ; 

修改为： const std::vector<PathOverlap> & pnc_junction_overlaps 
= reference_line_info-> reference_line ( ) . map_path ( ) . junction_overlaps () ;

（2）TrafficRule改为apollo::planning::TrafficRule

modules/planning/traffic_rules/region_speed_limit/plugin_region_speed_limit_description.xml

注：修改后不要忘了保存

（3）编译

在打开dreamview的终端执行下面代码

1

buildtool build -p modules/planning/traffic_rules/region_speed_limit/

(4)调参

将 limit_speed 由 15.0 改为 3.0

modules/planning/traffic_rules/region_speed_limit/conf/region_speed_limit.pb.txt

百度Apollo自动驾驶仿真平台9.0版本Perception模块相关内容

1. 首先安装nvidia驱动

2. 安装MiniConda

说明：如果已安装Anaconda则无需再安装Miniconda。

官网：MiniConda安装教程

或者参考我的教程：https://yang-makabaka.github.io/posts/4120ac2f.html

3. 安装PaddlePaddle

3.1. 创建并进入 conda 虚拟环境

注：每一步都需要在虚拟环境中进行。

1

conda create -n paddle_env python=3.8

1

source activate paddle_env

3.2. 本地安装cuda和cudnn

注：需要在上面创建的环境paddle_env中安装，如果没有进入，执行source activate paddle_env
执行下面命令,下图所示版本CUDA Version：12.0，需要注意的是此处显示的是当前驱动支持的cuda最大版本：

1

nvidia-smi

3.2.1. 查看conda支持的cuda版本

执行以下命令，查找源内所有cuda版本及对应下载地址：

1

conda search cudatoolkit --info

3.2.2. 下载cuda

找到自己想要的cuda版本后（以11.7.0版本为例），复制url字段里的下载链接，执行如下代码下载：

1
2

#wget 你刚刚复制的链接地址
wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/linux-64/cudatoolkit-11.7.0-hd8887f6_11.conda

3.2.3. 安装cuda

执行如下命令进行安装，因为是通过本地安装的，所以需要写明本地包的路径(上一步不改变下载路径的话，会默认下载到主文件夹，此时路径只写文件名即可):

1
2

#conda install --use-local 本地cuda包所在的路径
conda install --use-local cudatoolkit-11.7.0-hd8887f6_10.tar.bz2

3.2.4. 查看cuda对应的cudnn版本

由下图可知，paddle支持的 CUDA 11.7 对应的 cuDNN 版本为 v8.4.1 :

使用如下命令查看conda支持的cudnn版本，注意cudnn的版本一定要和刚刚下载的cuda版本对应：

1

conda search cudnn --info

3.2.5. 下载cudnn版本

同样复制链接，使用wget命令下载：

1

wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/linux-64/cudnn-8.4.1.50-hed8a83a_0.tar.bz2

3.2.6. 安装cudnn

1
2

#conda install --use-local 本地cudnn包所在的路径
conda install --use-local cudnn-8.4.1.50-hed8a83a_0.tar.bz2

3.3. 安装GPU版的PaddlePaddle

注：需要在上面创建的环境paddle_env中安装，如果没有进入，执行source activate paddle_env

3.3.1. 官网获取安装指令：

https://www.paddlepaddle.org.cn/install/quick?docurl=/documentation/docs/zh/install/pip/linux-pip.html

如下图所示，选择对应版本(以11.7版本为例)后，复制安装信息给出的指令到终端执行，等待安装完成：

注：执行命令报错怎么办（ValueError: Trusted host URL must include a host part: ‘#‘）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

##执行下面指令编辑pip配置文件：
vi ~/.pip/pip.conf

#会看到下面类似内容，第四行带有 # 注释，将注释语句删除即可：
1 [global]
2 index-url = https://pypi.tuna.tsinghua.edu.cn/simple
3 [install]
4 trusted-host = https://pypi.tuna.tsinghua.edu.cn  # trusted-host 此参数是为了避免麻烦，否则使用的

#修改后是这样的
1 [global]
2 index-url = https://pypi.tuna.tsinghua.edu.cn/simple
3 [install]
4 trusted-host = https://pypi.tuna.tsinghua.edu.cn

#附修改操作指令
#“i” 开始编辑，此时可通过方向键移动光标修改内容  
#“Esc” 退出编辑  
#“:wq” 保存退出

3.3.2. 验证安装

1
2
3
4
5
6
7
8
9
10
11
12
13

# 输入python进入python解释器
python

# 在python解释器中输入
import paddle

# 再输入
paddle.utils.run_check()

# 如果出现PaddlePaddle is installed successfully!，说明安装成功。

# 输入quit()退出python解释器
quit()

注：如果没有成功：

（1）查看路径

教程是非root用户创建的环境，命名为paddle_env，环境路径为~/.conda/envs/paddle_env，对应的第三方动态链接库地址为~/.conda/envs/paddle_env/lib，根据建立的环境名称，对应的路径为~/.conda/envs/[虚拟环境名称]/lib
若不清楚安装路径，可进入环境 paddle_env ，运行：

1

python -c "import paddle; print(paddle.**file**)"

  输出安装路径，结果为：

1

/home/ubuntu/.conda/envs/paddle_env/lib/python3.8/site-packages/paddle/**init**.py

1
2
3
4
5

对应的路径为
/home/ubuntu/.conda/envs/paddle_env/lib
或
~/.conda/envs/paddle_env/lib
#建议使用相对路径

（2）添加环境变量

1
2
3
4
5
6
7
8
9
10

#临时方案
#每次在程序运行前设置环境变量
export LD_LIBRARY_PATH=~/.conda/envs/paddle_env/lib
python xxx.py

#永久方案（推荐）
#将环境变量添加到~/.bashrc文件
echo "export LD_LIBRARY_PATH=~/.conda/envs/paddle_env/lib">>~/.bashrc
#添加后需要关闭终端重新打开或者登录。

4. 安装Paddle3D

4.1. 下载Paddle3D源码

建议在之前创建的数据文件夹 apolloDataSet 内打开终端下载，完成后会生成 Paddle3D 文件夹：

1

git clone https://github.com/PaddlePaddle/Paddle3D

4.2. 安装Paddle3D依赖

1
2
3
4
5
6
7
8

# 切换到Paddle3D文件夹
cd Paddle3D

#确保已进入虚拟环境paddle_env(已进入则忽略)
#source activate paddle_env

# 安装requirements.txt中要求的软件包
pip install -r requirements.txt

4.3. 安装Paddle3D

1
2

# 以编辑模式安装
pip install -e .

百度Apollo自动驾驶仿真平台9.0版本Planning模块相关内容

场景介绍：主车在城市道路行驶时，当遇到前方的故障车辆，为了保证行驶安全应及时减速并绕行，确保与障碍物之间的横向距离至少为1米，并控制绕行速度在5米/秒以内。

按照以下四步进行，不可跳过任何一步。

一、DreamView使用步骤

（1）在工程文件夹 ”application-pnc” 打开终端

（2）aem start

aem enter

aem bootstrap start

（3）运行成功后，在浏览器地址栏输入 “http://localhost:8888/”

（4）模式选择 Mkz Standard Debug，地图选择Apollo Virutal Map，打开Sim_Control模式，打开PNC Monitor，等待屏幕中间区域出现Mkz车辆模型和地图后即表示成功进入仿真模式。

（5）点击左侧Tab栏Module Controller，启动Planning，Prediction模块。

（6）打开场景 点击左侧Profile栏，选择创建的比赛场景，此时屏幕右上角多出选择场景的一栏，选择相应场景，车辆便会按场景预定路线行驶。

注：有时Planning，Prediction模块会自己关闭或者选择场景后车辆不动，再次打开模块，重新选择场景即可。

二、配置参数同步

1
2
3
4
5
6

**输⼊全局配置参数同步指令，系统将⾃动将全局配置参数复制到profile的default⽬录中，然后就可以在profile⽬录上轻松修改配置参数**
**buildtool profile config init --package planning --profile=default
buildtool profile config init --package planning-task-speed-bounds-decider --profile=default

使用default这份参数配置
aem profile use default**

三、代码修改

1.修改全局配置参数：

在 profiles/default/modules/planning/planning_base/conf/ 中找到planning.conf文件（推荐用vscode打开）。

（1）添加横向缓冲距离参数

在代码中添加下面代码段(为什么直接添加，因为在别的地方的绕行文件中已经有关于这个参数的配置，但是如果在这里加入这个参数配置的话，工程文件会优先使用此处的参数值，所以直接在此处，且更加方便直观)

1

**--obstacle_lat_buffer=1.5**

（2）修改全局速度和默认速度

将文件中的参数值（不用添加，文件中已有）修改为下面显示的值

1
2

**--planning_upper_speed_limit=11.18
--default_cruise_speed=11.18**

注意：被“#”注释的配置参数是不起作用的，如需使用应取消注释（快捷键Ctrl+/）

2.修改局部配置参数

在profiles/default/modules/planning/tasks/speed_bounds_decider/conf/下打开 default_conf.pb.txt 文件。

1
2
3
4
5
6

#注：以下为参数修改内容，但在实际实验中修改并没有效果，可能是某个地方中英文符号有问题，看看知道修改哪里就行
**# 将static_obs_nudge_speed_ratio: 0.6改为0.3
static_obs_nudge_speed_ratio: 0.3

#加上collision_safety_range配置⽂件
collision_safety_range: 5.0**

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#注：这是需要做的，直接将下面代码替换到default_conf.pb.txt 文件里即可，如下图。
total_time: 7.0
boundary_buffer: 0.25
max_centric_acceleration_limit: 0.8
point_extension: 0.0
lowest_speed: 0.1

static_obs_nudge_speed_ratio: 0.3

dynamic_obs_nudge_speed_ratio: 0.8
enable_nudge_slowdown: true
lane_change_obstacle_nudge_l_buffer: 0.3
max_trajectory_len: 1000.0

collision_safety_range: 5.0

注：修改好后记得保存修改 Ctrl+S 。

如果出现模块打不开或者障碍物不显示及场景不播放等问题，在打开dreamview的终端输入aem bootstrap restart重新启动即可。

之后在DreamView中重新开启Planning模块，再次选择场景，即可看到绕行时被控制在速度在5m/s以下。

四、提交评测

（1）压缩包制作

1
2

#进入工程文件夹，打开终端，输入下面代码，即可在工程文件夹里看到压缩包
tar -zcvf 自己取压缩包的名字.tar.gz modules/planning/ profiles/

（2）代码提交

将压缩包拖入提交区域即可，注意不要拖到别的地方。

目前只可在赛前练习提交测评，之后可在提交记录里查看成绩和测评结果。

百度Apollo自动驾驶仿真平台9.0版本Perception模块相关内容

一、感知模块代码结构

1、Camera代码结构

2、Lidar代码结构

3、Radar代码结构

4、Fusion代码结构

二、Lidar感知

1、组成分析

2、函数解析

（1）LidarDetectionComponent::Init()

进行Component初始化，通过该函数完成传感器的初始化，配置文件的读取，pipeline的配置文件初始化等操作。

（2）InternalProc()

是LidarDetectionComponent中的核心函数，该函数完成了点云数据的结构到LidarFrame数据结构的转换，并且会调用回调函数（具体的处理逻辑）

（3）LidarObstacleDetection::Init()

是Detection的初始化函数，该函数会通过Pipeline的配置文件，对各个Stage以及Task去进行一个实例化，并且对Stage的配置文件进行一个初始化的操作。

（4）LidarObstacleDetection::Process()

按照pipeline中配置文件的顺序，循环的调用各个不同Stage，不同Task的Process函数，用户可以根据自身的情况，设置不同的检测算法，以及不同的前后处理算法， 对Stage去进行一个不同的组合。

3、数据结构解析

1 查看点云数据

1
2

(1)终端输入
cyber_recorder play -f databag/sensor_rgb.record -l

1
2

（2）重新打开一个终端
cyber_monitor

选择激光雷达点云数据，右键打开查看

MessageType：channel的数据格式

FrameRatio：channel的帧率

header：channel的头文件信息（时间戳，时序，frame_id等信息）

Point：激光雷达点云的具体数据（包含点云的位置 强度 时间戳等信息）

2 在Dreamview查看点云数据

1
2

启动Dreamview
bash scripts/bootstrap_neo.sh

点击layer menu ——> 打开point cloud 就可以在Dreamiew上查看激光点云的数据。

3 激光雷达感知的数据结构

1
2

（1）使用如下命令播放数据包
cyber_recorder play -f databag/demo_3.5.record -l

1
2

（2）重新打开一个终端
cyber_monitor

选择 /apollo/perception/obstacles

perception_obstacle：感知中具体的感知结果

id：tracking之后的障碍物信息

position：障碍物在世界坐标系中的位置

theta：障碍物在世界坐标系中的朝向信息

velocity：障碍物的速度

length、width、height：障碍物的尺寸信息

type：障碍物的类型

三、感知传感器

四、课程链接

perception 2.0 综述_Apollo开发者社区

1. 确保所有系统包都是最新的

1
2

sudo apt update
sudo apt upgrade

2.官网下载miniconda

https://docs.conda.io/en/latest/miniconda.html#linux-installers

3.安装miniconda

（1）在文件下载目录打开终端，一般是Downloads，输入以下代码开始安装

1

sudo sh Miniconda3-py39_23.1.0-1-Linux-x86_64.sh(下载的文件名，根据实际下载的文件名更改)

根据提示按Ehter，和输入yes后，当询问安装到默认目录还是选择其它目录时，推荐输入下列位置代码（一般软件都安装到此）

1

/opt/miniconda3

初始化变量选择yes

（2）取消自动进入base环境

1

conda config --set auto_activate_base false

（3）手动初始化

安装vim

1

sudo apt-get install vim

输入下面代码设置环境变量

1

sudo vim /etc/bash.bashrc

将下面内容加到里面

vim操作教程：

i 开始编辑

Esc 退出编辑

:wq 保存退出

if [ -d "/opt/miniconda3/bin/" ] ; then  export PATH=/opt/miniconda3/bin:$PATHfi

（4）重载环境变量

1

source /etc/bash.bashrc

（5）换源

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/msys2/conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/conda config --set show_channel_urls yes

4.创建第一个虚拟环境

1
2
3

#envname:所创建的环境名字，要记住
#python=3.x:虚拟环境里python的版本，如python=3.6
conda create --name envname python=3.x

1

source activate #激活环境，此时终端行前会出现(base)

1

conda activate envname(上面创建的环境名) #此时行前括号内容由(bash)变为(你创建的环境名)

1
2
3
4
5
6
7
8

python
#此时输入python会有类似如下内容，现在就可以使用环境里的python了
#(opencv) yangfangzheng@yangfangzheng:~$ python
Python 3.6.15 | packaged by conda-forge | (default, Dec  3 2021, 18:49:41) 
[GCC 9.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print(1212)
1212

1

conda deactivate #退出虚拟环境

1

conda env remove -n 虚拟环境名 #删除已创建的虚拟环境

1

conda install python=3.9 #升级虚拟环境中的python版本,升级到python3.9,先进入到对应虚拟环境中，再执行

1
2
3
4
5

# 复制别人环境
#（1）将他人的虚拟环境，复制到/opt/miniconda3/envs
#（2）添加conda env
conda config --add envs_dirs /opt/miniconda3/envs/环境名
#（3）找到虚拟环境，进入bin目录，第一行修改为自己的路径。

5.出现问题怎么办？

E: 无法修正错误,因为您要求某些软件包保持现状,就是它们破坏了软件包间的依赖关系

首先需要安装 aptitude：

1

sudo apt-get install aptitude

aptitude 安装包：

1

sudo aptitude install openssh-server

如果方案中仍然存在未解决的依赖，可以选择 n，aptitude 会重新计算可行方案，包括对已存在的包进行降级等。

之后卸载conda，重装即可。

把像素点P(x,y)重新映射到一个新的位置P’(x’, y’)

像素重映射函数

cv.remap(src, map1, map2, interpolation[, dst[, borderMode[, borderValue]]] ) ->dst

​ •src表示图像

​ •map1表示x,y方向映射规则，或者x方向映射

​ •Map2如果map1表示x,y映射时为空，否则表示y

​ •表示映射时候的像素插值方法 支持：INTER_NEAREST 、NTER_LINEAR 、NTER_CUBIC

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#25像素重映射
def remap_demo():
    image = cv.imread("123.jpg")
    cv.namedWindow("remap-demo", cv.WINDOW_AUTOSIZE)
    cv.createTrackbar("remap-type", "remap-demo", 0, 3, trackbar_callback)
    h, w, c = image.shape
    cv.imshow("input", image)
    map_x = np.zeros((h, w), dtype=np.float32)
    map_y = np.zeros((h, w), dtype=np.float32)

    while True:
        pos = cv.getTrackbarPos("remap-type", "remap-demo")
        if pos == 0:  # 倒立
            for i in range(map_x.shape[0]):
                map_x[i, :] = [x for x in range(map_x.shape[1])]
            for j in range(map_y.shape[1]):
                map_y[:, j] = [map_y.shape[0] - y for y in range(map_y.shape[0])]
        elif pos == 1:  # 镜像
            for i in range(map_x.shape[0]):
                map_x[i, :] = [map_x.shape[1] - x for x in range(map_x.shape[1])]
            for j in range(map_y.shape[1]):
                map_y[:, j] = [y for y in range(map_y.shape[0])]
        elif pos == 2:  # 对象线对称
            for i in range(map_x.shape[0]):
                map_x[i, :] = [map_x.shape[1] - x for x in range(map_x.shape[1])]
            for j in range(map_y.shape[1]):
                map_y[:, j] = [map_y.shape[0] - y for y in range(map_y.shape[0])]
        elif pos == 3:  # 放大两倍
            for i in range(map_x.shape[0]):
                map_x[i, :] = [int(x/2) for x in range(map_x.shape[1])]
            for j in range(map_y.shape[1]):
                map_y[:, j] = [int(y/2) for y in range(map_y.shape[0])]

        dst = cv.remap(image, map_x, map_y, cv.INTER_LINEAR)
        cv.imshow("remap-demo", dst)
        c = cv.waitKey(100)
        if c == 27:
            break
    cv.destroyAllWindows()

26图像二值化

图像二值化定义

•只有两个像素值0、1(0表示黑色，1-255表示白色)，黑色表示背景，白色表示对象（规则）

图像二值化方法

•cv.mean,计算灰度图像均值m

•inRange方法分割

二值化函数

cv.threshold(src, thresh,maxval, type[,dst]) ->retval, dst

​ src表示输入图像

​ thresh表示阈值

​ maxval表示最大值

​ type表示 二值化THRESH_BINARY 或者 二值化反THRESH_BINARY_INV

​ retval表示返回阈值，dst返回的二值图像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 26图像二值化
def binary_demo():
    image = cv.imread("123.jpg")
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    cv.imshow("gray", gray)

    # 手动阈值，二值化
    ret, binary = cv.threshold(gray, 127, 255, cv.THRESH_BINARY)
    cv.imshow("binary",binary)
    cv.waitKey(0)

    # 求均值，二值化
    m = cv.mean(gray)[0]
    ret, binary = cv.threshold(gray, m, 255, cv.THRESH_BINARY)
    cv.imshow("binary", binary)
    cv.waitKey(0)

    cv.destroyAllWindows()

27全局与自适应二值化

全局二值化

（1）大津法（针对两峰）：0~5六个灰度级别，根据直方图分布，以每个灰度等级分割直方图分布为两个部分，分别求取均值跟方差，如图示，最小方法差和对应的灰度值为，分割阈值.

（2）三角法（针对单峰）

α和β角都为45°，最长的d对应的点偏移0.2即为阈值点。

两种方法都是基于直方图分布

全局二值化函数

cv.threshold(src, thresh,maxval, type[,dst]) ->retval,dst

​ •type表示二值化

​ •THRESH_BINARY | THRESH_OTSU 全局自动阈值＋二值化（大津）

​ •THRESH_BINARY | THRESH_TRIANGLE 全局自动阈值＋二值化（三角）

​ •THRESH_BINARY_INV | THRESH_OTSU

​ 表示不同的全局二值化方法

自适应二值化

•模糊图像 D（可以为均值模糊/高斯模糊）

•原图S + 加上偏置常量C

•T = S –D > -C ? 255 : 0

自适应二值化函数

cv.adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C[,dst] ) ->dst

​ •cv.ADAPTIVE_THRESH_MEAN_C 均值

​ cv.ADAPTIVE_THRESH_GAUSSIAN_C 高斯

​ •blockSize必须为奇数

​ •C表示要减去的权重，可以是正数，负数，0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 27全局与自适应二值化
def binarier_demo():
    image = cv.imread("123.jpg")
    gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    cv.imshow("gray", gray)

    # 手动阈值，大津法
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)
    cv.imshow("binary1", binary)
    cv.waitKey(0)

    # 手动阈值，三角法
    ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_TRIANGLE)
    cv.imshow("binary2", binary)
    cv.waitKey(0)

    # 自适应法
    binary = cv.adaptiveThreshold(gray, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 25, 10)
    cv.imshow("binary3", binary)
    cv.waitKey(0)

    cv.destroyAllWindows()

28实时人脸检测

OpenCV4 DNN模块

•来自另外一个开源项目tiny dnn

•OpenCV3.3正式发布

•最新版本OpenCV4.5.5

•支持后台硬件加速机制 CPU/GPU等

•支持多种任务(分类、检测、分割、风格迁移、场景文字检测等)

•只支持推理（模型部署），不支持模型训练

•支持主流的深度学习框架生成模型，OpenCV加载

•推荐使用pytorch/tensorflow

OpenCV人脸检测支持演化

•OpenCV3.3之前基于HAAR/LBP级联检测

•OpenCV3.3开始支持深度学习人脸检测

•支持人脸检测模型caffe/tensorflow

•OpenCV4.5.4 支持人脸检测+landmark

•模型下载地址：

•https://gitee.com/opencv_ai/opencv_tutorial_data

DNN相关函数

•读取模型：readNetFromTensorflow

•转换为blob对象：blobFromImage

•设置输入：setInput

•推理预测：forward

人脸检测显示

•模型输入:1x3x300x300

•模型输出:1xN（张人脸）x7（个数据）

​ 人脸检测框坐标（左上右下） – 后面四个值

​ 预测置信度（score） – 第三个值

​ class_id（类别） – 第一个值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

# 人脸检测
#下载下面两个模型到项目地址（https://gitee.com/opencv_ai/opencv_tutorial_data）
model_bin = "opencv_face_detector_uint8.pb"
config_text = "opencv_face_detector.pbtxt";

# 视频人脸检测
def video_detection():
    font = cv.FONT_HERSHEY_SIMPLEX
    font_scale = 0.5
    thickness = 1

    #load tensorflow model
    net = cv.dnn.readNetFromTensorflow(model_bin, config=config_text)
    capture = cv.VideoCapture(0) #获取摄像头图像
    # 人脸检测
    while True:
        e1 = cv.getTickCount()
        ret, frame = capture.read()
        frame = cv.flip(frame, 1)
        if ret is not True:
            break
        h, w, c = frame.shape
        blobImage = cv.dnn.blobFromImage(frame, 1.0, (300, 300), (104.0, 177.0, 123.0), False, False);
        net.setInput(blobImage)
        cvOut = net.forward()
        print(cvOut.shape)

        # Put efficiency information
        t, _ = net.getPerfProfile()
        label = 'Inference time: %.2f ms' % (t * 1000.0 / cv.getTickFrequency())

        # 绘制检测矩阵
        for detection in cvOut[0, 0, :, :]:
            score = float(detection[2])
            objIndex = int(detection[1])
            if score > 0.5:
                left = detection[3] * w
                top = detection[4] * h
                right = detection[5] * w
                bottom = detection[6] * h

                # 绘制矩形框
                cv.rectangle(frame, (int(left), int(top)), (int(right), int(bottom)), (255, 0, 0),thickness=2)

                # 绘制类别跟得分
                label_txt = "score: %.2f"%score
                (fw, uph), dh = cv.getTextSize(label_txt, font, font_scale, thickness)
                cv.rectangle(frame, (int(left), int(top) - uph - dh), (int(left) + fw, int(top)), (255, 255, 255), -1, 8)
                cv.putText(frame, label_txt, (int(left), int(top) - dh), font, font_scale, (255, 0, 255), thickness)

        e2 = cv.getTickCount()
        fps = cv.getTickFrequency() / (e2 - e1)
        cv.putText(frame, label + (" FPS: %.2f"%fps), (10, 50), cv.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255), 2)
        cv.imshow('face-detection-demo', frame)
        c = cv.waitKey(1)
        if c == 27:
            break
    cv.destroyAllWindows()

# 图片人脸检测
def image_detection():
    font = cv.FONT_HERSHEY_SIMPLEX
    font_scale = 0.5
    thickness = 1

    #load tensorflow model
    net = cv.dnn.readNetFromTensorflow(model_bin, config=config_text)
    capture = cv.VideoCapture(0)
    # 人脸检测
    e1 = cv.getTickCount()
    frame = cv.imread("face.png")
    h, w, c = frame.shape
    blobImage = cv.dnn.blobFromImage(frame, 1.0, (300, 300), (104.0, 177.0, 123.0), False, False);
    net.setInput(blobImage)
    cvOut = net.forward()
    print(cvOut.shape)

    # Put efficiency information
    t, _ = net.getPerfProfile()
    label = 'Inference time: %.2f ms' % (t * 1000.0 / cv.getTickFrequency())

    # 绘制检测矩阵
    for detection in cvOut[0, 0, :, :]:
        score = float(detection[2])
        objIndex = int(detection[1])
        if score > 0.5:
            left = detection[3] * w
            top = detection[4] * h
            right = detection[5] * w
            bottom = detection[6] * h

            # 绘制矩形框
            cv.rectangle(frame, (int(left), int(top)), (int(right), int(bottom)), (255, 0, 0), thickness=2)

            # 绘制类别跟得分
            label_txt = "score: %.2f" % score
            (fw, uph), dh = cv.getTextSize(label_txt, font, font_scale, thickness)
            cv.rectangle(frame, (int(left), int(top) - uph - dh), (int(left) + fw, int(top)), (255, 255, 255), -1, 8)
            cv.putText(frame, label_txt, (int(left), int(top) - dh), font, font_scale, (255, 0, 255), thickness)

    e2 = cv.getTickCount()
    fps = cv.getTickFrequency() / (e2 - e1)
    cv.putText(frame, label + (" FPS: %.2f" % fps), (10, 50), cv.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255), 2)
    cv.imshow('face-detection-demo', frame)
    c = cv.waitKey(0)
    cv.destroyAllWindows()

​

图像直方图函数

•calcHist(images, channels, mask,histSize, ranges[,hist[, accumulate]]) ->hist

•images表示图像

•channels表示通道

•mask 默认None

•histSzie表示bin的个数，灰度等级

•ranges表示通道的取值范围

函数返回的直方图数据类型为np.float32

1
2
3
4
5
6
7
8
9
10
11
12
13

#21图像直方图
def image_hist():
    image = cv.imread("123.jpg")
    cv.imshow("input", image)
    color = ('blue', 'green', 'red')
    for i,color in enumerate(color):
        hist = cv.calcHist([image], [i], None, [32], [0,256])
        print(hist.dtype)
        plt.plot(hist,color = color)
        plt.xlim([0,32])
    plt.show()
    cv.waitKey(0)
    cv.destroyAllWindows()

22直方图均衡化

均衡化作用

​ •提升对比度

​ •灰度图象支持

所谓均衡化就是减少Bin数量进而扩大各范围的差距

直方图均衡化函数

•cv.equalizeHist(src[, dst]) ->dst

•src必须是八位单通道图像*

•dst返回结果图像，类型与src保持一致

彩色直方图均衡化可以先转换到HSV空间然后对V通道均衡化（只对亮度通道增强）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#22直方图均衡化
def hist_equ():
    image = cv.imread("123.jpg",cv.IMREAD_GRAYSCALE)
    cv.imshow("input",image)
    hist = cv.calcHist([image], [0], None, [32], [0,256])
    print(hist.dtype)
    plt.plot(hist,color = "gray")
    plt.xlim([0,32])
    plt.show()
    cv.waitKey(0)

    eqimg = cv.equalizeHist(image)
    hist = cv.calcHist([eqimg], [0], None, [32], [0,256])
    print(hist.dtype)
    plt.plot(hist, color = "gray")
    plt.xlim([0,32])
    plt.show()
    cv.waitKey(0)
    cv.destroyAllWindows()

23图像卷积操作

卷积的本质是线性组合。

图像卷积定义

卷积的边缘填充

•边缘处理，边缘填充的方式

•（1）cv.BORDER_DEFAULT gfedcb|abcdefgh|gfedcba

•（2）cv.BORDER_WRAP cdefgh|abcdefgh|abcdefg

•（3）cv.BORDER_CONSTANT iiiiii|abcdefgh|iiiiiii

卷积模糊函数

•cv.blur( src,ksize[, dst[, anchor[,borderType]]]) ->*dst

​ •src表示输入图像 CV_8U, CV_32F or CV_64F*

​ •Ksize卷积核大小

​ •Anchor锚定位置（被平滑的点），默认值(-1,-1)，如果这个点坐标是负值的话，就表示取核的中心为锚点

​ •borderType边缘处理方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#23图像卷积操作
def conv_demo():
    image = cv.imread("123.jpg")
    dst = np.copy(image)
    cv.imshow("input",image)
    h, w, c = image.shape
    for row in range(1, h-1, 1):
        for col in range(1, w-1, 1):
            m = cv.mean(image[row-2:row+2, col-2:col+2])
            dst[row, col] = (int(m[0]), int(m[1]), int(m[2]))
    cv.imshow("convolution-demo", dst)

    # blured = cv.blur(image, (5,5), anchor=(-1, -1)) #修改Ksize数值调整模糊程度
    # cv.imshow("blur-demo", blured)

    cv.waitKey(0)
    cv.destroyAllWindows()

24高斯模糊

用高斯公式产生高斯卷积核

卷积核根据高斯函数生成，权重系数不同

高斯函数

cv.GaussianBlur(src, ksize, sigmaX[, dst[, sigmaY[, borderType]]]) ->dst

​ •ksize必须是正数而且是奇数（中心对称）

​ •sigmaX高斯核函数X方向标准方差

​ •sigmaY高斯核函数Y方向标准方差,默认0，表示跟sigmaX相同

​ •ksize==0表示从sigmaX计算生成ksize

​ •ksize >0 表示从ksize计算生成sigmaX，此时无视signaX所给的值

1
2
3
4
5
6
7
8
9
10
11

#24高斯模糊
def gaussian_blur_demo():
    image = cv.imread("123.jpg")
    cv.imshow("input",image)
    g1 = cv.GaussianBlur(image, (0, 0), 15)
    g2 = cv.GaussianBlur(image, (15, 15), 15)
    cv.imshow("GaussianBlur-demo1", g1)
    cv.imshow("GaussianBlur-demo2", g2)

    cv.waitKey(0)
    cv.destroyAllWindows()

•回调函数参数: int event, int x, int y, int flags, void **userdata*

•Event表示鼠标事件

•(x, y)表示当前鼠标位置

•Flags表示鼠标状态

•Userdata表示回调用户数据，可以为空

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

b1 = cv.imread("123.jpg")
img = np.copy(b1)
x1 = -1
y1 = -1
x2 = -1
y2 = -1
def mouse_drawing(event, x, y, flags, param):
    global x1, y1, x2, y2
    if event == cv.EVENT_LBUTTONDOWN:
        x1 = x
        y1 = y
    if event == cv.EVENT_MOUSEMOVE:
        if x1 <0 or y1 <0:
            return
        x2 = x
        y2 = y
        dx = x2 - x1
        dy = y2 - y1
        if dx > 0 and dy > 0:
            b1[:,:,:] = img[:,:,:]
            cv.rectangle(b1, (x1, y1), (x2, y2), (0, 0, 255), 2, 8, 0)
    if event == cv.EVENT_LBUTTONUP:
        x2 = x
        y2 = y
        dx = x2 - x1
        dy = y2 - y1
        if dx > 0 and dy > 0:
            b1[:,:,:] = img[:,:,:]
            cv.rectangle(b1, (x1, y1), (x2, y2), (0, 0, 255), 2, 8, 0)
        x1 = -1
        x2 = -1
        y1 = -1
        y2 = -1


def mouse_demo():
    cv.namedWindow("mouse_demo",cv.WINDOW_AUTOSIZE)
    cv.setMouseCallback("mouse_demo",mouse_drawing)
    while True:
        cv.imshow("mouse_demo",b1)
        c = cv.waitKey(10)
        if c == 27:
            break
    cv.destroyAllWindows()

18图像像素类型转换与归一化

归一化函数

•cv.normalize( src, dst[, alpha[, beta[, norm_type[, dtype[, mask]]]]] ) -> dst

•src表示输入图像, dst表示输出图像

•alpha, beta 默认是1， 0，是归一化的区间值

•norm_type默认是NORM_L2,

•norm_type常用是NORM_MINMAX

Imread读入默认是uint8, 转换为float32,通过imshow显示之前，必须归一化到[0~1]之间。

把float32的归一化图像转换为uint8类型：np.uint8(image*255)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#归一化
def trackbar_callback(pos):
    print(pos)

def norm_demo():
    image_unit8 = cv.imread("123.jpg")
    cv.imshow("image_uint8",image_unit8)
    img_f32 = np.float32(image_unit8)
    # cv.imshow("img_f32",img_f32)
    # cv.normalize(img_f32, img_f32, 1, 0, cv.NORM_MINMAX)
    # cv.imshow("norm-img_f32",img_f32)
    # cv.waitKey(0)
    # cv.destroyAllWindows()

    cv.namedWindow("norm_demo",cv.WINDOW_AUTOSIZE)
    cv.createTrackbar("mormtype", "norm_demo", 10, 3, trackbar_callback)
    while True:
        dst = np.float32(image_unit8)
        pos = cv.getTrackbarPos("normtype","norm-demo")
        if pos == 0:
            cv.normalize(dst, dst, 1, 0, cv.NORM_MINMAX)
        if pos == 1:
            cv.normalize(dst, dst, 1, 0, cv.NORM_L1)
        if pos == 2:
            cv.normalize(dst, dst, 1, 0, cv.NORM_L2)
        if pos == 3:
            cv.normalize(dst, dst, 1, 0, cv.NORM_INF)
        cv.imshow("norm-demo",img_f32)
        c = cv.waitKey(50)
        if c == 27:
            break
    cv.destroyAllWindows()

19图像几何变换

•cv.warpAffine(src, M, dsize[, dst[, flags[, borderMode[, borderValue]]]] ) -> dst

•src表示输入图像

•M 表示2x3变换矩阵

•dsize表示目标图像dst的大小

•支持平移变换、放缩变换、旋转变换

获取旋转矩阵

•旋转矩阵获取cv.getRotationMatrix2D

•Center表示旋转中心, angle表示度数，大于零表示逆时针旋转, scale表示放缩尺度大小。

翻转与特殊角度旋转

•cv.flip(src, flipCode[, dst] ) ->dst

•cv.rotate(src, rotateCode[, dst] ) -> dst

•src表示输入图像

•flipCode支持0水平、1垂直，-1对角线翻转，

•rotateCode支持旋转90°，180°，270°

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#图像几何变换
def affine_demo():
    image = cv.imread("123.jpg")
    h, w, c = image.shape
    cx = int(w / 2)
    cy = int(h / 2)
    cv.imshow("image",image)

    M = np.zeros((2,3), dtype=np.float32)
    M[0, 0] = .7
    M[1, 1] = .7
    M[0, 2] = 0
    M[1, 2] = 0
    print("M(2x3) = \n", M)
    dst = cv.warpAffine(image, M, (int(w*.7), int(h*.7)))
    cv.imshow("rescale-demo",dst)
    cv.imwrite("result.png",dst)

    #获取旋转矩阵，degree > 0 表示逆时针旋转，原点在左上角
    M = cv.getRotationMatrix2D((w/2, h/2), 45.0, 1.0)
    dst = cv.warpAffine(image, M, (w,h))
    cv.imshow("rotate-demo",dst)

    dst = cv.flip(image, 0)
    cv.imshow("flip-demo",dst)

    cv.waitKey(0)
    cv.destroyAllWindows()

20视频读写处理

视频标准与格式

•SD(Standard Definition)标清480P

•HD(High Definition)高清720P/1080P

•UHD(Ultra High Definition)超高清4K/2160P

•分辨率表示

•SD-640x480, 704x480, 720x480, 848x480等

•HD-960x720,1280x720,1440x1080,1920x1080

•UHD-4K,2160P

视频读取函数

cv.VideoCapture ( filename, index, apiPreference)

•filename表示视频文件

•Index表示USB摄像头或者web camera的索引

•apiPreference = CAP_ANY意思自动决定第三方视频库如： cv.CAP_FFMPEG， cv.CAP_DSHOW

查询视频属性

•VideoCaput的get方法

•cv.CAP_PROP_FRAME_WIDT

•cv.CAP_PROP_FRAME_HEIGHT

•cv.CAP_PROP_FPS（对视频流来说是0）

•cv.CAP_PROP_FOURCC

•cv.CAP_PROP_FRAME_COUNT

视频文件保存

cv.VideoWriter(

​ filename, 保存文件名称

​ fourcc, 编码方式

​ fps, 帧率

​ frameSize 视频帧大小，与实现大小相符，否则无法保存

​ [, isColor] )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#20视频读写处理
def video_demo():
    cap = cv.VideoCapture("456.avi")
    # query video file metadata
    fps = cap.get(cv.CAP_PROP_FPS)
    frame_w = cap.get(cv.CAP_PROP_FRAME_WIDTH)
    frame_h = cap.get(cv.CAP_PROP_FRAME_HEIGHT)
    print(fps, frame_w, frame_h)
    # encode mode
    # fourcc =cv.VideoWriter_fourcc(*'vp09')
    fourcc = cap.get(cv.CAP_PROP_FOURCC)
    # create Video writer
    writer = cv.VideoWriter('output.mp4', int(fourcc), fps, (int(frame_w), int(frame_h)))
    # loop read frame until last frame
    while True:
        ret, frame = cap.read()
        if ret is not True:
            break
        hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV)
        cv.imshow("hsv",hsv)
        cv.imshow("frame",frame)
        c = cv.waitKey(1)
        if c == 27:
            break
        writer.write(frame)

    # release camera resource
    cap.release()
    writer.release()

像素值统计-均值

•cv.mean(src[, mask] ) ->retval

像素值统计-方差

•cv.meanStdDev(src[, mean[, stddev[, mask]]]) ->mean, stddev

像素值统计-极值

•cv.minMaxLoc(src[, mask]) ->minVal, maxVal, minLoc, maxLoc

•src表示输入图像,mask表示计算区域

•mean, stddev, minVal, maxVal分别表示均值，标准方差，最小与最大

•cv2.convertScaleAbs()函数通过线性变换将数据转为均值，然后转换成8位[uint8]

每个通道分别计算均值和方差

通过图像方差判断是否含有有效信息

调整图像对比度的本质是调整图像之间的差值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import cv2
import numpy as np

image = cv2.imread("123.jpg")
cv2.imshow("demo1",image)
bgr_m = cv2.mean(image)
sub_m = np.float32(image)[:, :] - (bgr_m[0],bgr_m[1],bgr_m[2])
result = sub_m * 0.5
result = result[:, :] + (bgr_m[0],bgr_m[1],bgr_m[2])
cv2.imshow("低对比度",cv2.convertScaleAbs(result))

# result = sub_m *  2.0
# result = result[:, :] + (bgr_m[0],bgr_m[1],bgr_m[2])
# cv2.imshow("高对比度",cv2.convertScaleAbs(result))

cv2.waitKey(0)
cv2.destroyAllWindows()

14图像几何形状绘制

•支持绘制线、矩形、圆形

•支持填充矩形、圆形、椭圆

•支持绘制文本（不支持中文）

•相关函数cv.line()、cv.circle()、cv.rectangle()、cv.ellipse()、cv.putText()

•相关参数解释：

•img表示输入图像

•color表示颜色，如(255, 0,0)表示蓝色（必须与img的通道匹配）

•thickness表示线宽, 大于0表示绘制，小于0表示填充

•lineType表示渲染模式, 默认LINE_8（渲染周围8个点即8连通像素，性能有限使用）, LINE_AA表示反锯齿（质量更高）

文本绘制

•putText 默认只支持英文

•org表示文字起始坐标点

•fontFace表示字体类型

•fontScale表示字体大小

计算文本区域大小

1
2
3
4
5
6
7
8
9
10
11
12

#函数计算文本区域大小函数
getTextSize(

text, # 表示文本信息

fontFace, # 表示字体类型

fontScale, # 表示字体大小

thickness # 表示线宽
) 
#返回文本信息区域大小，与字体的基线baseline位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

def paint():
    canvas = np.zeros((512,512,3),dtype=np.uint8)

    #动态合理显示文本区域
    font_color = (140,199,0) #框颜色
    cv.rectangle(canvas,(100,100),(300,300),font_color,2,8) #框

    label_txt = "OpenCV"
    font = cv.FONT_HERSHEY_SIMPLEX  #字体
    font_scale = 0.5  #字体大小
    thickness = 1     #线宽
    (fw, uph),dh = cv.getTextSize(label_txt,font,font_scale,thickness)
    cv.rectangle(canvas,(100,100-uph-dh),(100+fw,100),(255,255,255),-1,8)
    cv.putText(canvas,label_txt,(100,100-dh),font,font_scale,(255,0,255),thickness)
    cv.imshow("canvas",canvas)
    cv.waitKey(0)

    cv.waitKey(0)
    cv.destroyAllWindows()

rectangle函数

cv2.rectangle(img, pt1, pt2, color, thickness, lineType, shift )

参数表示依次为：(图片，长方形框左上角坐标, 长方形框右下角坐标， 字体颜色，字体粗细）

在图片img上画长方形，坐标原点是图片左上角，向右为x轴正方向，向下为y轴正方向。左上角（x，y），右下角（x，y） ，颜色(B,G,R), 线的粗细

15随机数与随机颜色

Numpy随机数

•random.randint(low, high=None, size=None, dtype=int)

•Low表低值，high表示高值，size表示维度，dtype表示类型

•np.random.randint(256)

•np.random.randint(0, 256)

•表示产生0~255随机数，类型是int

•np.random.randint(0, 256, size=3) #size表示生成随机数的数量，用数组表示

随机噪声图

•cv.randn(dst, mean, stddev)

•生成目标图像dst

•噪声均值mean

•噪声方差stddev

•cv.randn(canvas, (40, 200, 140), (10, 50, 10)) #参数：图像，均值，方差

代码演示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def rando():
    canvas = np.zeros((512, 512, 3), dtype=np.uint8)
    # random draw
    while True:
        b,g,r = np.random.randint(0, 256, size=3)
        x1 = np.random.randint(0, 512)
        x2 = np.random.randint(0, 512)
        y1 = np.random.randint(0, 512)
        y2 = np.random.randint(0, 512)
        cv.rectangle(canvas,(x1,y1), (x2, y2), (int (b), int(g), int (r)), -1, 8)
        cv.imshow( "canvas",canvas)
        c = cv.waitKey(50)
        if c == 27:
            break
        cv.rectangle(canvas, (0,0), (512, 512), (0, 0, 0),-1, 8)

16多边形填充与绘制

绘制函数

•cv.fillPoly(img, pts, color[, lineType[, shift[, offset]]]) ->img

•填充多边形

•cv.polylines(img, pts, isClosed, color[, thickness[, lineType[, shift]]] ) ->img

•绘制多边形

•pts表示一个或者多个点集，polylines支持一次绘制多个多边形

•color表示颜色

•thickness表示线宽，注意：必须大于0

•lineType 表示渲染方式

点集支持

•pts表示一个或者多个点集

•pts = []

•pts.append((100, 100))

•pts.append((200, 50))

•pts.append((280, 100))

•pts.append((290, 300))

•pts.append((50, 300))

•pts = np.asarray(pts, dtype=np.int32)

•print(pts.shape)

•要求：必须是CV_32S, 对应np.int32

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

def paintmore():
    canvas = np.zeros((512, 512, 3), dtype=np.uint8)
    pts =[]
    pts.append((100, 100))
    pts.append((200, 50))
    pts.append((280, 100))
    pts.append((290, 300))
    pts.append((50, 300))
    pts = np.asarray(pts, dtype=np.int32) #必须是int32
    print(pts.shape)

    pts2 = []
    pts2.append((300, 300))
    pts2.append((400, 250))
    pts2.append((500, 300))
    pts2.append((500, 500))
    pts2.append((250, 500))
    pts2 = np.asarray(pts2, dtype=np.int32)
    print(pts2.shape)

    cv.polylines(canvas, [pts, pts2], True, (0, 0, 255), 2, 8)
    cv.fillPoly(canvas, [pts, pts2], (255, 0, 0), 8, 0)
    cv.imshow("poly-demo", canvas)
    cv.waitKey(0)
    cv.destroyAllWindows()

Callback回调基本流程

引用举例：你到一个商店买东西，刚好你要的东西没有货，于是你在店员那里留下了你的电话，过了几天店里有货了，店员就打了你的电话，然后你接到电话后就到店里去取了货。在这个例子里，你的电话号码就叫回调函数，你把电话留给店员就叫登记回调函数，店里后来有货了叫做触发了回调关联的事件，店员给你打电话叫做调用回调函数，你到店里去取货叫做响应回调事件。回答完毕。 (链接：https://www.zhihu.com/question/19801131)

先注册后使用

事件响应函数

•typedef void(* cv::TrackbarCallback) (int pos//滑块位置, void *userdata//用户数据，可不写)

•完成事件响应函数的声明与实现

•def trackbar_callback (pos):

​ print(pos)

创建窗口函数

•cv.namedWindow(winname [, flags]) -> None

•参数: winname表示窗口标题

•参数flags支持的flag有：

​ WINDOW_NORMAL – 可以调整窗口大小，图片很大时使用

​ WINDOW_AUTOSIZE – 根据图像大小自动适应，不可调

​ WINDOW_KEEPRATIO – 可以保持比例窗口，调整大小

调整图像亮度

•RGB值表示亮度

•RGB(0, 0,0) 黑色 -> RGB(255,255,255)白色，通过调整像素值来调整亮度

•add函数支持图像+图像与图像+常量方式

•subtract函数支持图像+图像与图像+常量方式

•动态调整，基于滚动条修改常量值，实现动态修改图像亮度并刷新显示

•创建图像窗口

•创建滚动条组件

•在窗口显示图像

•拖拉滚动条修改图像亮度

10键盘响应操作

键盘响应事件

•cv.waitKey( [, delay] ) ->retval

​ delay如果没有声明或者delay=0,表示一直阻塞

​ delay大于0，表示阻塞指定毫秒数

​ Retval返回的对应键盘键值，注意:在不同的操作系统中可能会有差异

​ 典型的retval = 27是ESC按键

响应不同的键盘操作

•检查返回键值，根据不同键值完成不同操作

•推荐使用if-elif-else, switch-case方式python3.10支持

if :

常见的色彩空间：HSV、RGB、YCrCb

​ RGB色彩空间，设备独立

​ HSV色彩空间，对计算机友好，区分各种色彩

​ YCrCb, Y分量表示信息，CrCb可以被压缩

​ RGB是计算机显示器的标准支持色彩系统

​ RGB的取值范围0~255

​ HSV取值范围H（色调）:0°~360°，S（饱和度）:0~255，V（明度）:0~255

从一个色彩空间转换到另外一个色彩空间要考虑：

​ 信息传递与损失过程、可逆与不可逆

函数与参数

​ cv.cvtColor(src,code[,dst[,dstCn]])->dst

​ · src表示输入图像, 类型CV_8U、CV_32F

​ · code表示，

​ cv::COLOR_BGR2RGB = 4

​ cv::COLOR_BGR2GRAY = 6

​ cv::COLOR_GRAY2BGR = 8

​ cv::COLOR_BGR2HSV = 40

​ 例：img2 = cv.cvtColor(img1, cv.COLOR_BGR2GRAY)

​ 注：当彩色图像转为灰度图像，由三通道转为单通道，其部分信息永久消失，再次转回BGR后图像变为三通道，但仍为灰色。

06 图像对象的创建与赋值

① OpenCV-Python支持的数据类型：np.uint8（默认）、np.float32（方便计算）、np.int32、np.int64

② Numpy常用函数：

​ numpy.array、numpy.zeros、numpy.zeros_like（快速产生与读入图像尺寸相同的纯黑图像）、numpy.asarray（将普通数组转为NumpyArray）、numpy.copy（复制图像）、numpy.reshape（各种转换）

​

函数解释：

​ (1) numpy.array(object, dtype=None, *, copy=True, order=’K’, subok=False, ndmin=0, like=None)

​ object 数组

​ dtype 数据类型

​ (2) numpy.zeros(shape, dtype=float, order=‘C’, *, like=None)

​ 数组维度

​ dtype 数据类型

​ (3) numpy.asarray(a, dtype=None, order=None, *, like=None)

​ 数组对象

​ dtype 数据类型

​ (4) numpy.reshape(a, newshape, order=’C’)

​ 数组维度

​ dtype 数据类型

③ 概念

​ opencv-python中一切图像数据皆numpy array

​ 创建图像就是创建numpy array

④ 创建图像

​ 1）导入import numpy as np

​ 2）创建np.array([[1, 2],[3, 4]], dtype=np.uint8)

​

​ 3）创建图像最常用函数：

​ np.zeros ->创建一个黑色背景图像

​ np.zeros_like->创建一个与输入图像大小一致的黑色背景图像

​ np.ones创建一个全部像素值是1的图像

⑤ 图像赋值

​ 图像赋值就是给numpy array数组赋值

​ m = np.zeros((3, 3, 3), dtype=uint8)

​ m[:] = 255，创建数组m，然后赋值为255(白色)

​ m[:] = (255,0,0)，创建数组m，然后赋值为(255,0,0)蓝色

​ h,w,c = img.shape，h,w,c分别为高，宽，通道

07 图像像素的读写操作

理解像素：

​ 像素实际大小：dpi x inches = 像素总数

​ 术语dpi：每英寸的点数目，96dpi – 针对打印

​ 术语ppi: 每英寸的像素数目 – 针对图像分辨率

OpenCV中像素

​ 矩阵表示每个像素信息

​ 像素遍历本质就是numpy数组访问

​ 假设变量image

​ 获取图像维度信息: image.shape

​ 图像访问像素: image[row, col]

​ 图像赋值像素: image[row, col] = (b,g,r)

​ 读写像素，彩色图像：

​ b, g, r = image[row, col]

​ image[row, col] = (255-b, 255-g, 255-r)

​ 读写像素，灰度图像：

​ pv = image[row, col]

​ image[row, col] = 255-pv

08 图像算数操作

图像读取后是一个数组，它可以进行基本的算术操作

加 cv.add(src1, src2[, dst[, mask[, dtype]]]) ->dst

减 cv.subtract(src1,src2[,dst[,mask[,dtype]]])->dst

mask参数控制操作范围，操作范围内正常加减，范围外全为0

乘 cv.multiply(src1,src2[,dst[,scale[,dtype]]])->dst

除 cv.divide(src1, src2[, dst[, scale[, dtype]]])->dst

参数说明 src1 & src2表示图像

加法运算保证不越界的方法：saturate(src1 + src2)-》0~255。saturate_cast函数的作用即是：当运算完之后，结果为负，则转为0，结果超出255，则为255。

图像算术运算要求：图像大小通道数目一致

加权加法：added_wt_img = cv2.addWeighted(img1, 0.6, img2, 0.4, 0)

mask表示模板（蒙版），为矩阵形式，矩阵中0，表示不取该位置的值，1表示保留该位置的值。

1.发展历史

•最早追溯到老子小孔成像

•现代1966年MIT的马文·明斯基的学生实现PC链接摄像机，标志计算机视觉作为一门学科开始发展

•1982.马尔文发布《视觉》标志着CV正式成为一门学科

•1999.David Lowe 发表SIFT特征相关论文，OpenCV收录使用

•2001.V&J发表基于HAAR特征的实时人脸检测算法

•2005.HOG提出特征提取的行人检测算法

•2006.Pascal VOC数据集发布

•2012.AlexNet模型赢得ImageNet图像分类比赛冠军，展现出深度学习在CV领域的应用前景

•未来世界离不开CV

2.主要任务

早期主要研究领域为重建

2012后，受深度学习影响重建与感知快速发展

目标：通过图灵测试

3.应用场景

•自动驾驶/辅助驾驶

•计算机视觉-AI + 机构/工业质检检测

…

•形成全场景的行业应用

二、计算机视觉框架

1.计算机视觉框架

•Matlab . 追溯到1970年 . 支持图像处理

•Matrox mil . 1993年发布第一个版本

•Halcon . 追溯到1996 . CV领域应用最多，主流框架

•OpenCV . 1999启动，2006发布1.0版本 . 开源

•VisionPro . 2009年发布

传统计算机视觉框架

•SimpleCV

•BoofCV

•Dlib

•JavaCV

深度学习计算机视觉（训练）框架

•Caffe

•Tensorflow

•Pytorch

•Paddlepaddle

•Keras

深度学习计算机视觉（部署）框架

•OpenVINO

•TensorRT

•onnxruntime

•Deepface

•YOLO/DarkNet

•mmdetection

•Paddle-detection/seg/ocr

2.当前主流框架

•机器视觉方向-Halcon/VisionPro/Mil/OpenCV

•深度学习方向-tensorflow/pytorch/paddlepaddle + openvino/tensorRT/onnxruntime

•主流语言Python/C++

3.计算机视觉框架的未来趋势

•低代码平台流行趋势明显

•传统视觉跟深度学习整合趋势明显

•算法设计流程化/可视化

•算法模块易用性跟通用性

•计算资源异构化支持趋势

•深度学习模型训练简捷化

三、OpenCV

•github: https://github.com/opencv

•Tutorial: https://docs.opencv.org/4.5.5/index.html

1.发展历史

•OpenCV在1999年的开始开发….

•2006年 OpenCV1.0正式发布（C）

•2009年 OpenCV2.0正式发布（C++）

•2012年 社区托管模式（开源）

•2015年 OpenCV3.0正式发布（完善接口）

•2018年 OpenCV4.0正式发布

•2022年4月份，4.5.5版本

2.OpenCV模块架构

3.OpenCV安装与支持

•Python SDK安装，推荐3.6.5

•OpenCV-Python安装 pip install opencv-python==4.5.4.60

​ (支持镜像安装-i https://pypi.tuna.tsinghua.edu.cn/simple)

•检查 pip list

python

Import cv2 as cv

cv.__version__

4.Intel Devcloud codelab使用

网址：devcloud.intel.com/edge（注册登录）

学习——教程——OpenCV Tutorial

四、图像读取与显示

计算机通过数值识别灰度或彩色图像

图像读取与显示

•import cv2 as cv – 导入OpenCV支持

•import numpy as np – 导入Numpy支持

•imread函数，读取图像

•imshow函数, 显示图像

•加载图像的通道顺序

•cv.imread(filename[,flags])

​ -filename 表示文件路径

​ -[]内的参数表示可选，可以不填

•cv.imshow( winname, mat) #BGR

​ -winname表示窗口标题

​ -mat 表示图像对象

•cv.waitKey(0) #表示一直等待，直到任意一个键盘操作

•cv.waitKey(1000) #表示等待1000毫秒即1秒

•cv.destroyAllWindows() #关闭窗口并取消分配任何相关的内存使用。对于一个简单的程序，实际上不必调用这些函数，因为退出时操作系统会自动关闭应用程序的所有资源和窗口

一、系统设置

1.换源

“软件和更新”——“Ubuntu软件”——“下载自”——改为“位于 中国的服务器”

2.显卡驱动

待更新。。。

3.界面优化

自己随心设置

“设置”——“外观”——“桌面图标“：关闭“显示个人文件夹

“设置”——“外观”——“Dock”:打开自动隐藏Dock,关闭面板模式，屏幕上的位置（底部）

“设置”——“鼠标和触摸板”——“触摸板”：打开自然滚动，调整触摸板速度，打开双指滚动

4.关闭更新

“软件和更新”——“更新”：根据自己的想法调整

5.关闭Dock栏显示其他分区磁盘（若出现此情况）

“磁盘”——选择对应磁盘及分区——“其他分区选项”——“编辑挂载选项”——关闭“用户会话默认值”——取消勾选“系统启动时挂载”、“显示用户界面”——确定即可

6.设置区域与语言

“设置”——“区域与语言”——“管理已安装的语言”——会提示语言支持没有安装完整，点击安装，完成后重启即可。

7.终端设置

自己随心设置

开启终端快捷键：Ctrl + Alt + T

打开终端——“设置——”“配置文件首选项”——点击配置文件首选项，”内置方案“选择“Linux控制台“，“以亮色显示粗体字”，即时生效。

8.修改用户目录为中文

打开终端输入以下命令：

1
2

export LANG=en_US
xdg-user-dirs-gtk-update

弹出对话框 ，不要勾选“下次别问我”之类的选项，选择更新名称。

终端输入：

1

export LANG=zh_CN

关闭终端，重启系统。

进入系统，系统会提示是否把目录改回中文，勾选“不要再次询问我”，选择保留旧的名称

9.命令优化（选做）

1、添加open命令

（1）打开当前目录

1
2

#打开var目录
nautilus /var

1
2
3
4
5
6
7
8
9
10
11

# 1. 编辑
vim /etc/profile

# 2.取别名
alias open="nautilus $1"

# 3.
source /etc/profile

# 4.打开文件夹
open .

（2）添加命令

1
2
3
4
5

vi ~/.bashrc  # 或者 gedit ~/.bashrc 个人习惯了vi 命令
#添加如下内容
alias open="nautilus ."
#使资源生效
source ~/.bashrc

（3）提示：vim操作

“i”：编辑插入

“Esc”键：退出编辑

输入 “:wq”：保存退出

10.科学上网

官网：https://www.clash.la/releases/

或：https://archive.org/download/clash_for_windows_pkg
（按自己系统版本选择）

将文件解压至/snap，终端或双击打开解压后的文件夹里的“cfw”

“General”——“Service Mode”——“Manage”——“Install”

“General”——打开“TUN Mode”

“General”——打开“start with Linux”（打开后每次开机会自动启动clash）

“Profiles”——在这添加自己的配置

11.GNOME Tweaks 和扩展（推荐，用于美化系统）

打开系统的商店，左上角搜索“GNOME”，安装“GNOME Tweaks”,之后在程序坞中找到“优化”打开，即可进行更多系统设置。
同时可安装“扩展管理器”，寻找更多扩展插件。

二、软件安装

Typora

（好用的markdown编辑器）
链接: https://pan.baidu.com/s/1atxTuNOmyeCL4cFiMd1BLg?pwd=jxsn 提取码: jxsn

(1)安装

1
2
3
4
5
6
7

#在所下载包的文件夹打开终端
tar xzvf Typora-linux-x64.tar.gz 
cd bin
sudo cp -ar Typora-linux-x64 /opt
cd /opt/Typora-linux-x64/
#启动
./Typora

（2）配置

设置环境变量

1

sudo vim ~/.bashrc

打开.bashrc配置文件，添加：

1
2

#Typora环境变量
export PATH=$PATH:/opt/Typora-linux-x64

source以下，让配置生效

1

source ~/.bashrc

之后可终端输入“Typora”直接打开。

（3）添加桌面面标

1
2

cd /usr/share/applications
sudo vim typora.desktop

添加以下内容，后重启系统：

1
2
3
4
5
6
7
8

[Desktop Entry]
Name=Typora
Comment=Typora
Exec=/opt/Typora-linux-x64/Typora
Icon=/opt/Typora-linux-x64/resources/app/asserts/icon/icon_256x256.png
Terminal=false
Type=Application
Categories=Developer;

打开终端输入下面内容：

1

gedit ~/.config/mimeapps.list

添加 text/markdown=typora.desktop;

更新于2024.4.18
准备内存至少为4G的U盘，最好8G及以上

1.准备工作

（1）下载Ubuntu镜像：下载Ubuntu桌面系统 | Ubuntu

（2）提前从存储分出空白区域

下载工具：Diskgenius，下载后解压运行即可

参考（下面步骤看不懂时看这个链接）：[Diskgenius教程](https://www.diskgenius.cn/help/partspliting.php）

慎重选择要分出空间的分区，右键该分区，点击『拆分分区』，『分区后部的空间』即为分给ubuntu的空间，同时注意将其设置为『保持空闲』，完成后在界面左上角有类似『保存修改』选项，点击保存。

（3）（仅windows有BitLocker进行这步操作，且必须）
如何知道自己电脑是否开启BitLocker：查看Diskgenius
查看是否有链接中第一张图所示（分区有加密字样）：Diskgenius

①可按照链接方法解锁
②还可以参考

（4）下载U盘启动盘制作工具：

​ 官网：Rufus - 轻松创建USB启动盘

​ or网盘链接: https://pan.baidu.com/s/1BnXpb-07EtqTBXt28gpFHQ?pwd=1234 提取码: 1234

2.安装U盘制作

1）将要制作的 U 盘插入电脑，打开Rufus

2）在分区方案和目标系统类型选项中选择用于UEFI计算机的GPT分区方案，文件系统 选择 NTFS

3）点击光盘图标选择好下载的光盘镜像文件

4）点击“开始”进行制作，显示“准备就绪”后，关闭Rufus

3.安装

1）重启，进BIOS（不同品牌电脑按键不同，可根据电脑型号去网上查找，参考https://zhuanlan.zhihu.com/p/34223088），关闭安全启动（将【Secure Boot】设置为【Disabled】）。选择U盘（前面制作的启动盘）启动，保存重启。

2）在欢迎页面左右选择「中文（简体）」，再点击右侧的「安装 Ubuntu」按钮。

3）选择chinese，最小安装，取消安装时下载更新，取消安装第三方软件（根据自身需要设置）

4）分区

推荐双硬盘，在第二块硬盘安装，不会发生引导冲突，更稳定

若只想保留Ubuntu而删除Windows，选择“清除整个磁盘并安装”即可

由于作者磁盘安装有多个系统，因此选择“其他选项”自己分配空间

自用方案：按照下表顺序，依次从上面分出的空白区域中创建相应分区，注意千万不要选择错分区，不然数据无法恢复，若不会创建分区可搜索其他博客学习，写的匆忙故不做演示。

特别注意：下面『安装启动器位置』的选项选择上面创建的大小为500m的EFI分区对应的分区名称。

5）之后经过一些设置，安装完成后重启电脑，重启时即可拔掉U盘

以后电脑的引导会使用grub引导器，开机用上下键选择想进入的系统，默认为ubuntu，进windows需选择windows boot manager项，同时也可设置默认windows启动，可自行查资料解决。

6.1）（多系统可能出现的问题）Ubuntu引导顶掉原先引导

​ 方法:重新进入BIOS将启动首选项改回

6.2） 自用，请勿模仿，仅供自己参考：（本人使用OC引导）

①找到OC引导所在的位置，将\EFI\OC\config.plist备份

②将磁盘OC引导所在的EFI分区中的ubuntu文件夹移动到安装时分配的EFI分区（建立名为EFI的文件夹，将文件放入其中，原位置的ubuntu文件夹删除）

③重新替换OC分区的EFI文件夹，后将上面备份的config.plist导入新EFI文件夹（替换即可）

④重启进BIOS将启动首选项改为OC引导，保存退出重启即可进入系统选择界面

至此Ubuntu系统安装步骤全部完成

如果磁盘空间足够的话，建议备份系统，以防崩溃时快速恢复。

1.PyTorch生态简介

https://datawhalechina.github.io/thorough-pytorch/第八章/index.html

PyTorch的强大很大程度上取决于它的生态。

（1）torchvision

（2）PyTorchVideo

PytorchVideo 提供了加速视频理解研究所需的模块化和高效的API。它还支持不同的深度学习视频组件，如视频模型、视频数据集和视频特定转换，最重要的是，PytorchVideo也提供了model zoo，使得人们可以使用各种先进的预训练视频模型及其评判基准。

基于 PyTorch，高质量model zoo，支持主流数据集及预处理，模块化设计，支持多模态，移动端部署优化

（3）torchtext

• 数据处理工具 torchtext.data.functional、torchtext.data.utils
• 数据集 torchtext.data.datasets
• 词表工具 torchtext.vocab
• 评测指标 torchtext.metrics

构建数据集

• Field及其使用

①构建Field

1
2
3

tokenize = lambda x: x.split()
TEXT = data.Field(sequential=True, tokenize=tokenize, lower=True, fix_length=200)
LABEL = data.Field(sequential=False, use_vocab=False)

②进一步构建dataset

1
2
3
4
5
6
7
8
9
10
11
12
13
14

from torchtext import data
def get_dataset(csv_data, text_field, label_field, test=False):
    fields = [("id", None), # we won't be needing the id, so we pass in None as the field
                 ("comment_text", text_field), ("toxic", label_field)]       
    examples = []

    if test:
        # 如果为测试集，则不加载label
        for text in tqdm(csv_data['comment_text']):
            examples.append(data.Example.fromlist([None, text, None], fields))
    else:
        for text, label in tqdm(zip(csv_data['comment_text'], csv_data['toxic'])):
            examples.append(data.Example.fromlist([None, text, label], fields))
    return examples, fields

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

train_data = pd.read_csv('train_toxic_comments.csv')
valid_data = pd.read_csv('valid_toxic_comments.csv')
test_data = pd.read_csv("test_toxic_comments.csv")
TEXT = data.Field(sequential=True, tokenize=tokenize, lower=True)
LABEL = data.Field(sequential=False, use_vocab=False)

# 得到构建Dataset所需的examples和fields
train_examples, train_fields = get_dataset(train_data, TEXT, LABEL)
valid_examples, valid_fields = get_dataset(valid_data, TEXT, LABEL)
test_examples, test_fields = get_dataset(test_data, TEXT, None, test=True)
# 构建Dataset数据集
train = data.Dataset(train_examples, train_fields)
valid = data.Dataset(valid_examples, valid_fields)
test = data.Dataset(test_examples, test_fields)

# 检查keys是否正确
print(train[0].__dict__.keys())
print(test[0].__dict__.keys())
# 抽查内容是否正确
print(train[0].comment_text)

• 词汇表（vocab）

构建词语到向量（或数字）的映射关系

在torchtext中可以使用Field自带的build_vocab函数完成词汇表构建。

1

TEXT.build_vocab(train)

• 数据迭代器

1
2
3
4
5
6
7
8
9
10
11
12
13
14

from torchtext.data import Iterator, BucketIterator
# 若只针对训练集构造迭代器
# train_iter = data.BucketIterator(dataset=train, batch_size=8, shuffle=True, sort_within_batch=False, repeat=False)

# 同时对训练集和验证集进行迭代器的构建
train_iter, val_iter = BucketIterator.splits(
        (train, valid), # 构建数据集所需的数据集
        batch_sizes=(8, 8),
        device=-1, # 如果使用gpu，此处将-1更换为GPU的编号
        sort_key=lambda x: len(x.comment_text), # the BucketIterator needs to be told what function it should use to group the data.
        sort_within_batch=False
)

test_iter = Iterator(test, batch_size=8, device=-1, sort=False, sort_within_batch=False)

2.PyTorch模型部署

https://datawhalechina.github.io/thorough-pytorch/第九章/index.html

ONNX

（1）ONNX简介

①ONNX

• ONNX官网：https://onnx.ai/
• ONNX GitHub：https://github.com/onnx/onnx

通过定义一组与环境和平台无关的标准格式，使AI模型可以在不同框架和环境下交互使用。

使用不同框架训练的模型，转化为ONNX格式后，可以很容易的部署在兼容ONNX的运行环境中。

②ONNX Runtime

• ONNX Runtime官网：https://www.onnxruntime.ai/
• ONNX Runtime GitHub：https://github.com/microsoft/onnxruntime

跨平台机器学习推理加速器，可直接读取 .onnx 格式的文件。

③安装

ONNX和ONNX Runtime的适配关系：https://github.com/microsoft/onnxruntime/blob/master/docs/Versioning.md

使用GPU进行推理时，需要卸载onnxruntime，再安装onnxruntime-gpu，同时还需考虑ONNX Runtime与CUDA之间的适配关系，参考链接

1
2
3
4
5
6
7

# 激活虚拟环境
conda activate env_name # env_name换成环境名称
# 安装onnx
pip install onnx 
# 安装onnx runtime
pip install onnxruntime # 使用CPU进行推理
# pip install onnxruntime-gpu # 使用GPU进行推理

（2）模型导出为ONNX

使用torch.onnx.export()把模型转换成 ONNX 格式的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import torch.onnx 
# 转换的onnx格式的名称，文件后缀需为.onnx
onnx_file_name = "xxxxxx.onnx"
# 我们需要转换的模型，将torch_model设置为自己的模型
model = torch_model
# 加载权重，将model.pth转换为自己的模型权重
# 如果模型的权重是使用多卡训练出来，我们需要去除权重中多的module. 具体操作可以见5.4节
model = model.load_state_dict(torch.load("model.pth"))
# 导出模型前，必须调用model.eval()或者model.train(False)
model.eval()
# dummy_input就是一个输入的实例，仅提供输入shape、type等信息 
batch_size = 1 # 随机的取值，当设置dynamic_axes后影响不大
dummy_input = torch.randn(batch_size, 1, 224, 224, requires_grad=True) 
# 这组输入对应的模型输出
output = model(dummy_input)
# 导出模型（需确保我们的模型处在推理模式）
torch.onnx.export(model,        # 模型的名称
                  dummy_input,   # 一组实例化输入
                  onnx_file_name,   # 文件保存路径/名称
                  export_params=True,        #  如果指定为True或默认, 参数也会被导出. 如果你要导出一个没训练过的就设为 False.
                  opset_version=10,          # ONNX 算子集的版本，当前已更新到15
                  do_constant_folding=True,  # 是否执行常量折叠优化
                  input_names = ['input'],   # 输入模型的张量的名称
                  output_names = ['output'], # 输出模型的张量的名称
                  # dynamic_axes将batch_size的维度指定为动态，
                  # 后续进行推理的数据可以与导出的dummy_input的batch_size不同
                  dynamic_axes={'input' : {0 : 'batch_size'},    
                                'output' : {0 : 'batch_size'}})

（3）可用性检查

1
2
3
4
5
6
7
8
9
10

import onnx
# 我们可以使用异常处理的方法进行检验
try:
    # 当我们的模型不可用时，将会报出异常
    onnx.checker.check_model(self.onnx_model)
except onnx.checker.ValidationError as e:
    print("The model is invalid: %s"%e)
else:
    # 模型可用时，将不会报出异常，并会输出“The model is valid!”
    print("The model is valid!")

（4）可视化

Netron

第七章：PyTorch可视化 — 深入浅出PyTorch (datawhalechina.github.io)

7.1 可视化网络结构

使用torchinfo来可视化网络结构

• torchinfo的安装

1
2
3
4

# 安装方法一
pip install torchinfo 
# 安装方法二
conda install -c conda-forge torchinfo

• torchinfo的使用

只需使用torchinfo.summary()，

必需的参数分别是model，input_size[batch_size,channel,h,w]

更多参数可以参考documentation

1
2
3
4
5

# 例
import torchvision.models as models
from torchinfo import summary
resnet18 = models.resnet18() # 实例化模型
summary(resnet18, (1, 3, 224, 224)) # 1：batch_size 3:图片的通道数 224: 图片的高宽

torchinfo提供了更加详细的信息，包括模块信息（每一层的类型、输出shape和参数量）、模型整体的参数量、模型大小、一次前向或者反向传播需要的内存大小等。

7.2 CNN可视化

7.2.1 卷积核可视化

卷积核在CNN中负责提取特征，可视化卷积核能够帮助人们理解CNN各个层在提取什么样的特征，进而理解模型的工作原理。

在PyTorch中可视化卷积核也非常方便，核心在于特定层的卷积核即特定层的模型权重，可视化卷积核就等价于可视化对应的权重矩阵。

首先加载模型，并确定模型的层信息：

1
2
3
4
5

import torch
from torchvision.models import vgg11

model = vgg11(pretrained=True)
print(dict(model.features.named_children()))

卷积核对应的应为卷积层（Conv2d），这里以第“3”层为例，可视化对应的参数：

1
2
3
4
5
6
7
8
9
10
11
12
13

conv1 = dict(model.features.named_children())['3']
kernel_set = conv1.weight.detach()
num = len(conv1.weight.detach())
print(kernel_set.shape)
for i in range(0,num):
    i_kernel = kernel_set[i]
    plt.figure(figsize=(20, 17))
    if (len(i_kernel)) > 1:
        for idx, filer in enumerate(i_kernel):
            plt.subplot(9, 9, idx+1) 
            plt.axis('off')
            plt.imshow(filer[ :, :].detach(),cmap='bwr')
torch.Size([128, 64, 3, 3])

由于第“3”层的特征图由64维变为128维，因此共有128*64个卷积核，其中部分卷积核可视化效果如下图所示：

7.2.2 特征图可视化

输入的原始图像经过每次卷积层得到的数据称为特征图，可视化即查看模型提取到的特征是什么样的。

hook：PyTorch提供的使得网络在前向传播过程中能够获取到特征图的一个专用接口。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

class Hook(object): #定义Hook类
    def __init__(self):
        self.module_name = []
        self.features_in_hook = []
        self.features_out_hook = []

    def __call__(self,module, fea_in, fea_out):
        print("hooker working", self)
        self.module_name.append(module.__class__)
        self.features_in_hook.append(fea_in)
        self.features_out_hook.append(fea_out) #存储当前层的输入和输出
        return None
    

def plot_feature(model, idx, inputs):
    hh = Hook()
    model.features[idx].register_forward_hook(hh)  #该hook类的对象注册到要进行可视化的网络的某层中
    
    # forward_model(model,False)
    model.eval()
    _ = model(inputs)
    print(hh.module_name)
    print((hh.features_in_hook[0][0].shape))
    print((hh.features_out_hook[0].shape))
    
    out1 = hh.features_out_hook[0]

    total_ft  = out1.shape[1]
    first_item = out1[0].cpu().clone()    

    plt.figure(figsize=(20, 17))
    

    for ftidx in range(total_ft):
        if ftidx > 99:
            break
        ft = first_item[ftidx]
        plt.subplot(10, 10, ftidx+1) 
        
        plt.axis('off')
        #plt.imshow(ft[ :, :].detach(),cmap='gray')
        plt.imshow(ft[ :, :].detach())

7.2.3 class activation map可视化

class activation map （CAM）的作用是判断哪些变量（可视化场景下为像素点）对模型来说是重要的。

同时为了判断重要区域的梯度等信息，衍生出了Grad-CAM等诸多变种。

相较于上两条，CAM能一目了然地确定重要区域，进而进行可解释性分析或模型优化改进。

实现方法：

pytorch-grad-cam

• 安装

1

pip install grad-cam

• 一个简单的例子

1
2
3
4
5
6
7
8
9
10
11
12
13

import torch
from torchvision.models import vgg11,resnet18,resnet101,resnext101_32x8d
import matplotlib.pyplot as plt
from PIL import Image
import numpy as np

model = vgg11(pretrained=True)
img_path = './dog.png'
# resize操作是为了和传入神经网络训练图片大小一致
img = Image.open(img_path).resize((224,224))
# 需要将原始图片转为np.float32格式并且在0-1之间 
rgb_img = np.float32(img)/255
plt.imshow(img)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

from pytorch_grad_cam import GradCAM,ScoreCAM,GradCAMPlusPlus,AblationCAM,XGradCAM,EigenCAM,FullGrad
from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
from pytorch_grad_cam.utils.image import show_cam_on_image

target_layers = [model.features[-1]]
# 选取合适的类激活图，但是ScoreCAM和AblationCAM需要batch_size
cam = GradCAM(model=model,target_layers=target_layers)
targets = [ClassifierOutputTarget(preds)]   
# 上方preds需要设定，比如ImageNet有1000类，这里可以设为200
grayscale_cam = cam(input_tensor=img_tensor, targets=targets)
grayscale_cam = grayscale_cam[0, :]
cam_img = show_cam_on_image(rgb_img, grayscale_cam, use_rgb=True)
print(type(cam_img))
Image.fromarray(cam_img)

7.2.4 FlashTorch快速可视化

对环境有要求：https://github.com/MisaOgura/flashtorch/issues/39

• 安装

1

pip install flashtorch

• 可视化梯度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# Download example images
# !mkdir -p images
# !wget -nv \
#    https://github.com/MisaOgura/flashtorch/raw/master/examples/images/great_grey_owl.jpg \
#    https://github.com/MisaOgura/flashtorch/raw/master/examples/images/peacock.jpg   \
#    https://github.com/MisaOgura/flashtorch/raw/master/examples/images/toucan.jpg    \
#    -P /content/images

import matplotlib.pyplot as plt
import torchvision.models as models
from flashtorch.utils import apply_transforms, load_image
from flashtorch.saliency import Backprop

model = models.alexnet(pretrained=True)
backprop = Backprop(model)

image = load_image('/content/images/great_grey_owl.jpg')
owl = apply_transforms(image)

target_class = 24
backprop.visualize(owl, target_class, guided=True, use_gpu=True)

• 可视化卷积核

1
2
3
4
5
6
7
8
9
10
11

import torchvision.models as models
from flashtorch.activmax import GradientAscent

model = models.vgg16(pretrained=True)
g_ascent = GradientAscent(model.features)

# specify layer and filter info
conv5_1 = model.features[24]
conv5_1_filters = [45, 271, 363, 489]

g_ascent.visualize(conv5_1, conv5_1_filters, title="VGG16: conv5_1")

7.3 使用TensorBoard可视化训练过程

可视化你所想可视化的所有内容。

7.3.1安装

1

pip install tensorboardX

7.3.2可视化的基本逻辑

TensorBoard会将模型每一层的数据保存在指定位置 并以网页的形式可视化。

7.3.3 配置与启动

①首先指定一个文件夹供TensorBoard保存记录下来的数据，然后调用tensorboard中的SummaryWriter。

1
2
3

from tensorboardX import SummaryWriter

writer = SummaryWriter('./指定位置') #可手动往文件夹里添加数据，也可以提取到其他机器

※如果使用PyTorch自带的tensorboard，则采用如下方式import：

1

from torch.utils.tensorboard import SummaryWriter

②启动tensorboard

1
2
3

tensorboard --logdir=/path/to/logs/ --port=xxxx
#“path/to/logs/"是指定的保存tensorboard记录结果的文件路径
#port是外部访问TensorBoard的端口号，可以通过访问ip:port访问tensorboard

7.3.4 模型结构可视化

首先定义模型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3,out_channels=32,kernel_size = 3)
        self.pool = nn.MaxPool2d(kernel_size = 2,stride = 2)
        self.conv2 = nn.Conv2d(in_channels=32,out_channels=64,kernel_size = 5)
        self.adaptive_pool = nn.AdaptiveMaxPool2d((1,1))
        self.flatten = nn.Flatten()
        self.linear1 = nn.Linear(64,32)
        self.relu = nn.ReLU()
        self.linear2 = nn.Linear(32,1)
        self.sigmoid = nn.Sigmoid()

    def forward(self,x):
        x = self.conv1(x)
        x = self.pool(x)
        x = self.conv2(x)
        x = self.pool(x)
        x = self.adaptive_pool(x)
        x = self.flatten(x)
        x = self.linear1(x)
        x = self.relu(x)
        x = self.linear2(x)
        y = self.sigmoid(x)
        return y

model = Net()
print(model)

输出如下：

1
2
3
4
5
6
7
8
9
10
11

Net(
  (conv1): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1))
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv2): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1))
  (adaptive_pool): AdaptiveMaxPool2d(output_size=(1, 1))
  (flatten): Flatten(start_dim=1, end_dim=-1)
  (linear1): Linear(in_features=64, out_features=32, bias=True)
  (relu): ReLU()
  (linear2): Linear(in_features=32, out_features=1, bias=True)
  (sigmoid): Sigmoid()
)

可视化模型的思路和7.1中介绍的方法一样，都是给定一个输入数据，前向传播后得到模型的结构，再通过TensorBoard进行可视化，使用add_graph：

1
2

writer.add_graph(model, input_to_model = torch.rand(1, 3, 224, 224))
writer.close()

展示结果如下（其中框内部分初始会显示为“Net”，需要双击后才会展开）：

7.3.5 TensorBoard图像可视化

• 对于单张图片的显示使用add_image
• 对于多张图片的显示使用add_images
• 有时需要使用torchvision.utils.make_grid将多张图片拼成一张图片后，用writer.add_image显示

以torchvision的CIFAR10数据集为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

import torchvision
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

transform_train = transforms.Compose(
    [transforms.ToTensor()])
transform_test = transforms.Compose(
    [transforms.ToTensor()])

train_data = datasets.CIFAR10(".", train=True, download=True, transform=transform_train)
test_data = datasets.CIFAR10(".", train=False, download=True, transform=transform_test)
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=64)

images, labels = next(iter(train_loader))
 
#依次进行以下三组可视化
# 仅查看一张图片
writer = SummaryWriter('./pytorch_tb')
writer.add_image('images[0]', images[0])
writer.close()
 
# 将多张图片拼接成一张图片，中间用黑色网格分割
# create grid of images
writer = SummaryWriter('./pytorch_tb')
img_grid = torchvision.utils.make_grid(images)
writer.add_image('image_grid', img_grid)
writer.close()
 
# 将多张图片直接写入
writer = SummaryWriter('./pytorch_tb')
writer.add_images("images",images,global_step = 0)
writer.close()

7.3.6 TensorBoard连续变量可视化

适合损失函数的可视化，可以更加直观地了解模型的训练情况，从而确定最佳的checkpoint。

1
2
3
4
5
6
7

writer = SummaryWriter('./pytorch_tb')
for i in range(500):
    x = i
    y = x**2
    writer.add_scalar("x", x, i) #日志中记录x在第step i 的值
    writer.add_scalar("y", y, i) #日志中记录y在第step i 的值
writer.close()

可视化结果如下：

如果想在同一张图中显示多个曲线，则需要分别建立存放子路径（使用SummaryWriter指定路径即可自动创建，但需要在tensorboard运行目录下），同时在add_scalar中修改曲线的标签使其一致即可：

1
2
3
4
5
6
7
8
9

writer1 = SummaryWriter('./pytorch_tb/x')
writer2 = SummaryWriter('./pytorch_tb/y')
for i in range(500):
    x = i
    y = x*2
    writer1.add_scalar("same", x, i) #日志中记录x在第step i 的值
    writer2.add_scalar("same", y, i) #日志中记录y在第step i 的值
writer1.close()
writer2.close()

7.3.7 TensorBoard参数分布可视化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#举例
import torch
import numpy as np

# 创建正态分布的张量模拟参数矩阵
def norm(mean, std):
    t = std * torch.randn((100, 20)) + mean
    return t
 
writer = SummaryWriter('./pytorch_tb/')
for step, mean in enumerate(range(-10, 10, 1)):
    w = norm(mean, 1)
    writer.add_histogram("w", w, step)
    writer.flush()
writer.close()

7.3.8 服务器端使用TensorBoard

（1）MAC端

打开终端，输入的命令依次如下：

打开tensorflow的运行环境:source activate tensorflow
进入log的目录文件夹：cd desktop/tensorflow/
输入tensorboard命令：tensorboard —logdir=”log”

在浏览器中输入网址：http:localhost:6006

（2）MobaXterm

1. 在MobaXterm点击Tunneling
2. 选择New SSH tunnel，我们会出现以下界面。

1. 对新建的SSH通道做以下设置，第一栏我们选择Local port forwarding，<Remote Server>我们填写localhost，< Remote port>填写6006，tensorboard默认会在6006端口进行显示，我们也可以根据 tensorboard —logdir=/path/to/logs/ —port=xxxx的命令中的port进行修改，< SSH server> 填写我们连接服务器的ip地址，<SSH login>填写我们连接的服务器的用户名，<SSH port>填写端口号（通常为22），< forwarded port>填写的是本地的一个端口号，以便我们后面可以对其进行访问。
2. 设定好之后，点击Save，然后Start。在启动tensorboard，这样我们就可以在本地的浏览器输入http://localhost:6006/对其进行访问了

（3）Xshell

1. Xshell的连接方法与MobaXterm的连接方式本质上是一样的，具体操作如下：
2. 连接上服务器后，打开当前会话属性，会出现下图，我们选择隧道，点击添加
3. 按照下方图进行选择，其中目标主机代表的是服务器，源主机代表的是本地，端口的选择根据实际情况而定。
4. 启动tensorboard，在本地127.0.0.1:6006 或者 localhost:6006进行访问。

（4）SSL

该方法是将服务器的6006端口重定向到自己机器上来，我们可以在本地的终端里输入以下代码：其中16006代表映射到本地的端口，6006代表的是服务器上的端口。

1

ssh -L 16006:127.0.0.1:6006 username@remote_server_ip

在服务上使用默认的6006端口正常启动tensorboard

1

tensorboard --logdir=xxx --port=6006

在本地的浏览器输入地址

1

127.0.0.1:16006 或者 localhost:16006

DataWhale在线文档：https://datawhalechina.github.io/thorough-pytorch/第六章/index.html

6.1 自定义损失函数

在科学研究中，我们往往会提出全新的损失函数来提升模型的表现，此时我们需要自己设计损失函数。

（1）以函数方式定义

1
2
3