JetsonNano指南

注意，本指南原本只针对4GB版本使用，后期因为使用2GB版本而新增加了一部分内容，有区别的均已经标注

具体资源请参照JetsonNano开发者套件（2GB版本：Jetson Nano 2GB Developer Kit）、Jetson Linux开发手册、Jetson Zoo（各种开源框架及其安装说明）

一、入门

1.准备

SD卡：大于16G，最好64G，class10，下载Jetson Nano Developer Kit SD Card ImageSD卡镜像（2GB版本： Jetson Nano 2GB Developer Kit SD Card Image），并用 SD Memory Card Formatter for Windows格式化SD卡然后用Etcher刷写入SD卡（仅限于Windows）
Micro-USB电源线（最大支持5V2A）或专用电源线（最大5V4A，推荐，该方式需要将跳线帽接上。2GB无需关心，4GB版本默认接上）
USB无线网络适配器：可选

2.开始

将microSD卡（已写入系统映像）插入Jetson Nano模块底部的插槽中。接上各种外设即可进入系统

目前安装的最新版JetPack SDK为4.4，具体包含内容可以参见官方链接

二、基本环境搭建

1.更换国内源

更换为清华源，注意这里采用的是ARM设备的源，对应的是ubuntu-ports镜像：

1 2	sudo mv /etc/apt/sources.list /etc/apt/sources.list.bak sudo vim /etc/apt/sources.list

对应的配置文件为：

# 默认注释了源码镜像以提高 apt update 速度，如有需要可自行取消注释
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-updates main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-updates main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-backports main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-backports main restricted universe multiverse
deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-security main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-security main restricted universe multiverse

# 预发布软件源，不建议启用
# deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-proposed main restricted universe multiverse
# deb-src https://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-proposed main restricted universe multiverse

阿里源：

deb http://mirrors.aliyun.com/ubuntu-ports/ bionic main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu-ports/ bionic main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu-ports/ bionic-security main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu-ports/ bionic-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu-ports/ bionic-updates main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu-ports/ bionic-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu-ports/ bionic-backports main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu-ports/ bionic-backports main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu-ports/ bionic-proposed main restricted universe multiverse
# deb-src http://mirrors.aliyun.com/ubuntu-ports/ bionic-proposed main restricted universe multiverse

更新：

1 2	sudo apt-get update sudo apt-get upgrade

2.安装CUDA

由于Jeston Nano中已经安装了CUDA，但是需要更改环境变量之后，才能够查询到版本信息，所以首先添加环境变量：

1	sudo vim ~/.bashrc

在最后添加：

1
2
3

export CUDA_HOME=/usr/local/cuda-10.2
export LD_LIBRARY_PATH=/usr/local/cuda-10.2/lib64:$LD_LIBRARY_PATH
export PATH=/usr/local/cuda-10.2/bin:$PATH

保存后更新：

1	source ~/.bashrc

检查：

nvcc -V

3.配置python

注意：

目前anaconda官方已经支持arm64位版本，但是实测目前能够安装上，但是不能正常的创建环境——2021/7/20

推荐使用conda-forge/miniforge: A conda-forge distribution.，支持conda命令，能够正常的创建环境，但是只能使用conda-forge源，不推荐换源（换源之后尝试过创建环境失败）

由于Jetson Nano中已经预装了Python3.6版本，所以可以直接安装pip。

在终端中输入下述命令进行安装：

1	sudo apt-get install python3-pip python3-dev python3-venv

python3-venv是管理虚拟环境的包，由于conda没有arm版本的，所以推荐用venv管理虚拟环境
可以此时同时安装autoenv自动激活插件，配合venv使用（注意换源）：
1
pip3 install autoenv
- autoenv需要在.bashrc最后添加以下脚本才能使用：
  1
  source `which activate.sh`
  - 如果找不到activate.sh，一般都在~/.local/bin/activate.sh

安装完成后此时的pip是9.01版本，需要对pip进行一下升级，否则后面在安装其它Python库的时候会出问题。这里顺带着将pip的源换了：

# 临时换源升级pip
python3 -m pip install --upgrade pip -i https://pypi.tuna.tsinghua.edu.cn/simple
# 换源
python3 -m pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
# 测试版本
python3 -m pip --version

换源之后的pip源保存在/home/jetson/.config/pip/pip.conf下
阿里源：https://mirrors.aliyun.com/pypi/simple
- 阿里源记得在配置文件~/.config/pip/pip.conf中加入以下选项：
  1
  2
  [install]
  trusted-host=mirrors.aliyun.com
  否则会在用pip下载时一直弹出警告

安装常用库（还是建议在虚拟环境中用pip安装）：

1
2
3

sudo apt-get install python3-scipy
sudo apt-get install python3-pandas
sudo apt-get install python3-sklearn

4.安装Code OSS

不再推荐，VSC已经支持arm版本

原生的VS Code并不适用于Jetson Nano，当前，还没有针对Jetson Nano这样的ARM设备的VS Code正式版本。但是，由于它是开源的，所以任何人都可以编译一个版本。其中，Code-OSS就是这样一款嵌入式环境下的“VS Code”。Code-OSS基于VS Code，它并不仅仅是一个代码编辑器，它具有用于管理整个项目文件夹而不是单个脚本的内置资源管理器功能以及丰富的第三方插件。实际上Code-OSS几乎具备了VS Code的所有完整功能，因此用它作为代码编辑器来编辑代码，例如python，会使得整个开发过程更加便捷。

官方的VSC-OSS没有ARM版本的，但是该网址为第三方对ARM的适配版本，只需选择后缀带有arm64(aarch64)的，单击后进入详情页面后，找到对应的wget命令即可：

1	wget --content-disposition https://packagecloud.io/headmelted/codebuilds/packages/debian/stretch/code-oss_1.45.0-1586135971_arm64.deb/download.deb

下载后直接安装：

1	sudo dpkg -i code-oss_1.45.0-1586135971_arm64.deb

5.安装OPENCV

手动编译参考链接：Build OpenCV on Nvidia Jetson Nano（手动编译opencv脚本，详见后文）、Installing OpenCV 3.4.6 on Jetson Nano

如果在conda环境中，可以直接通过pip安装：
1
pip install opencv-contrib-python
四种opencv的区别：

opencv-python: 只包含opencv库的主要模块. 一般不推荐安装

opencv-contrib-python: 包含主要模块和contrib模块, 功能基本完整, 推荐安装

opencv-python-headless: 和opencv-python一样, 但是没有GUI功能, 无外设系统可用

opencv-contrib-python-headless: 和opencv-contrib-python一样但是没有GUI功能. 无外设系统可用

注意：
如果需要安装QT，带GUI的版本会与QT冲突
上述几种opencv均不带GStreamer支持，而jetson Nano上读取csi摄像头需要通过GStreamer读取，可以通过以下命令查询当前opencv版本的支持情况：
1
2
import cv2
print(cv2.getBuildInformation())

默认自带opencv 4.1.1，可以通过如下命令测试：

1	sudo opencv_version

其中opencv的：

头文件目录为：/usr/include/opencv4
库文件目录为：/usr/lib/aarch64-linux-gnu
常用链接库：-lopencv_core -lopencv_imgcodecs -lopencv_imgproc -lopencv_highgui -lopencv_objdetect -lopencv_videoio

5.1python环境

默认系统的python版本分别为python3.6和python2.7，所以在系统中使用这两个版本是不需要任何设置的，此时可以直接import cv2即可

但是如果当前环境不是上述两个版本，或者说是在虚拟环境中，则需要设置下opecv

注意：

使用pip安装的opencv默认是cpu版本的，不能全部发挥出jetson的性能。

不推荐直接使用系统环境的python，推荐自己创建虚拟环境。（系统带的python中有些库需要通过apt安装）

一般来说有如下两种方式：

链接系统默认的opencv到对应的python环境中（仅适用于虚拟环境和系统的python版本一致时，在虚拟环境中直接将系统环境中的opencv库链接过来）
重新编译opencv，并链接到python环境中（该方式详见第三章）

这里先采用上述第一种方式。一般来说，jetson中默认的opencv库放在如下两个路径：

/usr/lib/python3.6/dist-packages/cv2/python-3.6/cv2.cpython-36m-aarch64-linux-gnu.so：系统默认python3.6版本的库文件
/usr/lib/python2.7/dist-packages/cv2/python-2.7/cv2.so：系统默认python2.7的库文件

找到目前使用的python环境，将上述库文件链接到site-packages文件夹下即可（如果没有就自行创建）。一般来说有如下两种情况：

系统中的python路径：/usr/lib/python3.8/site-packages/
虚拟环境中的python路径：./env/lib/python3.8/site-packages/

之后创建opencv库的软连接到目标python环境中即可：

1	ln -s opencv库文件(xxx.so) cv2.so

5.2摄像头读取

读取摄像头参数

针对硬件的各种参数，可以通过以下命令获取：

# 安装依赖
sudo apt install v4l-utils
# 检测摄像头
v4l2-ctl --list-devices
# 检测摄像头支持的格式
v4l2-ctl -d /dev/video1 --list-formats-ext
# 检查摄像头设置
v4l2-ctl -d /dev/video1 --list-ctrls

读取CSI摄像头异常

如果因为有另一个任务使用同一摄像头（挂起或活动）而导致当前任务不能使用该摄像头并报错时，可以通过如下方式重置 nvargus-daemon 来解决：

1	sudo service nvargus-daemon restart

CSI摄像头

读取CSI摄像头主要使用Gstreamer，可以通过如下命令测试摄像头：

1
2
3

nvgstcapture
# 或者
gst-launch-1.0 nvarguscamerasrc sensor-id=0 sensor-mode=3 ! 'video/x-raw(memory:NVMM),width=3820, height=2464, framerate=21/1, format=NV12' ! nvvidconv flip-method=0 ! 'video/x-raw,width=960, height=616' ! nvvidconv ! nvegltransform ! nveglglessink -e

如下参数也可以（指定默认摄像头与采集模式）：

gst-launch-1.0 nvarguscamerasrc ! 'video/x-raw(memory:NVMM),width=3820, height=2464, framerate=21/1, format=NV12' ! nvvidconv flip-method=0 ! 'video/x-raw,width=960, height=616' ! nvvidconv ! nvegltransform ! nveglglessink -e

opencv中的调用方法：

python：

import cv2

# 设置gstreamer管道参数
def gstreamer_pipeline(
    sensor_id=0,
    sensor_mode=3,
    capture_width=1280, #摄像头预捕获的图像宽度
    capture_height=720, #摄像头预捕获的图像高度
    display_width=1280, #窗口显示的图像宽度
    display_height=720, #窗口显示的图像高度
    framerate=60,       #捕获帧率
    flip_method=0,      #是否旋转图像
):
    return (
        "nvarguscamerasrc sensor-id=%d sensor-mode=%d ! "
        "video/x-raw(memory:NVMM), "
        "width=(int)%d, height=(int)%d, "
        "format=(string)NV12, framerate=(fraction)%d/1 ! "
        "nvvidconv flip-method=%d ! "
        "video/x-raw, width=(int)%d, height=(int)%d, format=(string)BGRx ! "
        "videoconvert ! "
        "video/x-raw, format=(string)BGR ! appsink"
        % (
            sensor_id,
            sensor_mode,
            capture_width,
            capture_height,
            framerate,
            flip_method,
            display_width,
            display_height,
        )
    )

if __name__ == "__main__":
    # 创建管道 
	print(gstreamer_pipeline())

    #管道与视频流绑定
    cap = cv2.VideoCapture(gstreamer_pipeline(flip_method=0), cv2.CAP_GSTREAMER)

    if cap.isOpened():
        window_handle = cv2.namedWindow("CSI Camera", cv2.WINDOW_AUTOSIZE)

        # 逐帧显示
        while cv2.getWindowProperty("CSI Camera", 0) >= 0:
            ret_val, img = cap.read()
            cv2.imshow("CSI Camera", img)

            keyCode = cv2.waitKey(30) & 0xFF         
            if keyCode == 27:# ESC键退出
                break

        cap.release()
        cv2.destroyAllWindows()
    else:
        print("打开摄像头失败")

注意：jetson Nano 中，需要 opencv 支持 GStreamer 才可以从 csi 摄像头中读取数据，可以通过以下命令查询是否支持 GStreamer ：
1
2
import cv2
print(cv2.getBuildInformation())

C++：

#include <iostream>
#include <string>
#include <opencv2/opencv.hpp>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/objdetect.hpp>
#include <opencv2/imgproc/types_c.h>
#include <opencv2/videoio.hpp>

using namespace std;
using namespace cv;

string gstreamer_pipeline (int sensor_id, int sensor_mode, int capture_width, int capture_height, int display_width, int display_height, int framerate, int flip_method)
{
    return "nvarguscamerasrc sensor-id=" + to_string(sensor_id) + " sensor-mode=" + to_string(sensor_mode) + " ! video/x-raw(memory:NVMM), width=(int)" + to_string(capture_width) + ", height=(int)" +
        to_string(capture_height) + ", format=(string)NV12, framerate=(fraction)" + to_string(framerate) +
        "/1 ! nvvidconv flip-method=" + to_string(flip_method) + " ! video/x-raw, width=(int)" + to_string(display_width) + ", height=(int)" +
        to_string(display_height) + ", format=(string)BGRx ! videoconvert ! video/x-raw, format=(string)BGR ! appsink";
}

int main( int argc, char** argv )
{
    int capture_width = 1280 ;
    int capture_height = 720 ;
    int display_width = 1280 ;
    int display_height = 720 ;
    int framerate = 60 ;
    int flip_method = 0 ;
    int sensor_id = 0;
    int sensor_mode = 3;

    //创建管道
    string pipeline = gstreamer_pipeline(sensor_id,
                                         sensor_mode,
                                         capture_width,
                                         capture_height,
                                         display_width,
                                         display_height,
                                         framerate,
                                         flip_method);
    std::cout << "使用gstreamer管道: \n\t" << pipeline << "\n";

    //管道与视频流绑定
    VideoCapture cap(pipeline, CAP_GSTREAMER);
    if(!cap.isOpened())
    {
        std::cout<<"打开摄像头失败."<<std::endl;
        return (-1);
    }

    //创建显示窗口
    namedWindow("CSI Camera", WINDOW_AUTOSIZE);
    Mat img;

    //逐帧显示
    while(true)
    {
        if (!cap.read(img))
        {
            std::cout<<"捕获失败"<<std::endl;
            break;
        }
        imshow("CSI Camera",img);

        int keycode = cv::waitKey(30) & 0xff ; //ESC键退出
        if (keycode == 27) break ;
    }

    cap.release();
    destroyAllWindows() ;
}

NVIDIA提供了一个基于python的cam库：JetCam，可以通过用过该库来调用摄像头（本质上还是调用Gstreamer）：

下载源码，解压
1
unzip jetcam-master.zip

安装

1 2	cd jetcam-master sudo python3 setup.py install

使用

import cv2
from jetcam.csi_camera import CSICamera
camera = CSICamera(capture_device=0, width=224, height=224, capture_width=1080, capture_height=720, capture_fps=30)
image = camera.read()  # BGR8
print(image.shape)
print(camera.value.shape)
while 1:
    image = camera.read()
    cv2.imshow("CSI Camera", image)
    kk = cv2.waitKey(1)
    if kk == ord('q'):  # 按下 q 键，退出
        break
cv2.destroyAllWindows()

USB摄像头

opencv中的调用方法：

1 2	cv2.VideoCapture(0) cv2.VideoCapture(1)

JetCam库中的调用方法：

import cv2
from jetcam.usb_camera import USBCamera
camera = USBCamera(capture_device=1)
image = camera.read()
print(image.shape)
print(camera.value.shape)
while 1:
    image = camera.read()
    cv2.imshow("USB Camera", image)
    kk = cv2.waitKey(1)
    if kk == ord('q'):  # 按下 q 键，退出
        break

6.安装VNC服务

注意：该方案目前在JetPack SDK 4.4上失效，暂时未找到解决方法

解决bug

<key name='enabled' type='b'>
  <summary>Enable remote access to the desktop</summary>
  <description>
    If true, allows remote access to the desktop via the RFB
    protocol. Users on remote machines may then connect to the
    desktop using a VNC viewer.
  </description>
  <default>false</default>
</key>

安装必备软件
1
2
sudo apt update
sudo apt install vino

安装VNC server

自带有VNC，只需设置使能即可：

1	sudo ln -s ../vino-server.server /usr/lib/systemd/user/graphical-session.target.wants

配置VNC server

1
2
3

gsettings set org.gnome.Vino enabled true
gsettings set org.gnome.Vino prompt-enabled false
gsettings set org.gnome.Vino require-encryption  false

设置密码

1 2	gsettings set org.gnome.Vino authentication-methods "['vnc']" gsettings set org.gnome.Vino vnc-password $(echo -n 'thepassword'\|base64)

重启机器

1	sudo reboot

连接VNC server：用VNC客户端连接即可

设置桌面分辨率：由显示器决定，默认640*480，可以通过编辑/etc/X11/xorg.conf文件，加入以下内容修改分辨率：

Section "Screen"
   Identifier    "Default Screen"
   Monitor       "Configured Monitor"
   Device        "Tegra0"
   SubSection "Display"
       Depth    24
       Virtual 1280 800 # Modify the resolution by editing these values
   EndSubSection
EndSection

注意：VNC server只有当用户登录后才能使用，如果希望VNC能够自动启动，可以使能自动登录功能

实验：水流检测代码环境搭建

注意，这里需要用到以下几个包：

opencv
numpy
matplotlib
skimage

其中skimage对python的最低版本支持为3.7，所以需要先安装python3.7以上版本，并基于此创建虚拟环境：

sudo apt install python3.8 python3.8-dev python3.8-venv
python3.8 -m venv waterspeed-env
# 在虚拟环境中直接下载安装：
pip install numpy skimage matplotlib

下载安装过程会比较漫长，因为有些包没有arm64平台的，需要在本地编译

手动编译并安装opencv

如果仅仅是编译 python 中的 opencv，推荐 opencv 官方的 python：opencv/opencv-python: Automated CI toolchain to produce precompiled opencv-python, opencv-python-headless, opencv-contrib-python and opencv-contrib-python-headless packages

跟着 Manual builds 章节手动编译即可

一般来说，jetson Nano上需要添加以下环境变量：
1
2
3
4
5
6
7
8
9
10
11
# 开启多核心编译（parallel build）
export CMAKE_BUILD_PARALLEL_LEVEL=$(nproc)
# 导出编译opencv的环境变量
export CMAKE_ARGS="-DWITH_GSTREAMER=ON -DWITH_LIBV4L=ON -DWITH_OPENGL=ON -DWITH_QT=5 -DWITH_V4L=ON"
# 编译完整包（包含主要模块和 contrib/额外模块）
export ENABLE_CONTRIB=1
# 编译没有界面支持的opencv
# export ENABLE_HEADLESS=1
pip wheel . --verbose # 开始编译
# 或者通过以下 pip 命令根据当前上下文环境编译安装（不采用官方提供的镜像）
# pip install --no-binary opencv-contrib-python opencv-contrib-python -v
编译过程中需要 qt5 的支持，此时需要已经安装 qt5：
1
sudo apt install qt5-default
编译完成后会在当前目录下生成最后的 whl 文件

安装numpy时需要通过conda安装（会提供其他依赖），opencv-python项目中提供的numpy（pip仓库的也没有）没有提供这些依赖
有时候编译过程中会因为之前的缓存而导致最后链接时失败，此时删除_skbuild文件夹即可：
1
rm -r _skbuild

编译

手动完整编译一次opencv 4.4.0在jetson nano 2GB上预计5~6小时

opencv比较特殊，推荐直接编译然后创建软连接的方式安装，当然也可以通过apt的方式直接安装（该方式安装的是cpu版本，且已经过时（系统环境默认带了opencv），仅供参考）：[[第一次用Jetson Nano 就上手]OpenCV基础应用](https://www.rs-online.com/designspark/jetson-nano-opencv-1-cn)

可以根据前文提到的GitHub上的开源脚本来一部编译、配置opencv：Build OpenCV on Nvidia Jetson Nano
1
git clone  https://github.com/mdegans/nano_build_opencv.git
需要有梯子从外网拉取代码opencv源码

下载对应的仓库：

1 2	git clone --depth 1 --branch 4.4.0 https://github.com/opencv/opencv.git git clone --depth 1 --branch 4.4.0 https://github.com/opencv/opencv_contrib.git

注意：上述4.4.0是opencv的版本号，需要自己根据github仓库分支确定

配置opencv：

# 到opencv/build（没有build就自己创建）下执行
cmake -D BUILD_EXAMPLES=OFF \
        -D BUILD_opencv_python2=ON \
        -D BUILD_opencv_python3=ON \
        -D CMAKE_BUILD_TYPE=RELEASE \
        -D CMAKE_INSTALL_PREFIX=/home/jetson/opencv \
        -D CUDA_ARCH_BIN=5.3,6.2,7.2 \
        -D CUDA_ARCH_PTX= \
        -D CUDA_FAST_MATH=ON \
        -D CUDNN_VERSION='8.0' \
        -D EIGEN_INCLUDE_PATH=/usr/include/eigen3 \
        -D ENABLE_NEON=ON \
        -D OPENCV_DNN_CUDA=ON \
        -D OPENCV_ENABLE_NONFREE=ON \
        -D OPENCV_EXTRA_MODULES_PATH=/home/jetson/package/nano_build_opencv/build_opencv/opencv_contrib/modules \
        -D OPENCV_GENERATE_PKGCONFIG=ON \
        -D WITH_CUBLAS=ON \
        -D WITH_CUDA=ON \
        -D WITH_CUDNN=ON \
        -D WITH_GSTREAMER=ON \
        -D WITH_LIBV4L=ON \
        -D WITH_OPENGL=ON \
        ..

注意以下配置需要自定义：
- CMAKE_INSTALL_PREFIX：指定的安装目录，不推荐到全局目录（需要sudo权限）
- OPENCV_EXTRA_MODULES_PATH：外部模块目录，即opencv_contrib/modules

编译并安装到本地：

# 编译
make -j4
# 安装到指定目录
make install

编译过程中如果遇到以下问题：
- fatal error: boostdesc_bgm.i: No such file or directory：网络问题，编译时还需要下载一部分文件，此时无法下载完成，所以失败。
  1. 详见fatal error: boostdesc_bgm.i: No such file or directory · Issue #1301最后一部分，给出了缺少文件的下载链接，手动下载放到对应文件夹即可
  2. 不断重试，直至成功下载完成缺少的文件

建议安装之后通过如下方式打包备份opencv：

# 打包
tar -jcvf opencv4.4.0.tar.bz2 ./opencv
# 解压
tar jxvf opencv4.4.0.tar.bz2

链接到python虚拟环境

经历过上述步骤后，opencv正确的安装到了指定的路径，此时需要将opencv的库链接到python中来：

# 找到刚刚编译的opencv的python库路径
cd opencv/lib/python3.8/site-packages/cv2/python-3.8
# 重命名库文件
mv cv2.cpython-36m-xxx-linux-gnu.so cv2.so
# 去虚拟环境中的site-packages文件夹
cd ./env/lib/python3.8/site-packages/
# 如果不是虚拟环境就直接去家目录的的全局python环境下
cd ~
# 链接库文件
ln -s ~/opencv/lib/python3.8/site-packages/cv2/python-3.8/cv2.so cv2.so

此时，opencv可以通过如下方式测试版本：

1
2
3

import cv2
cv2.__version__
print(cv2.getBuildInformation())

pytorch安装

官方参考链接：PyTorch for Jetson - version 1.8.0 now available

对于Python 2.7与Python 3.6来说，在上面的链接中找到合适的版本直接下载安装即可，对于其他版本的python需要自己手动从源码编译

编译

注意：

该过程在jetson nano 4GB版本上需要12小时左右（不包括torchvision）

自带的4G ram+2G swap小了，编译时会报工具链错误，这里直接将虚拟内存加到了10G

最好单独创建一个虚拟环境进行编译

打开交换分区（如果有则不需要）：Create a Linux swap file

# 创建交换分区文件（dd或fallocate二选一即可）
# sudo dd if=/dev/zero of=/swapfile bs=64M count=16#count的大小就是增加的swap空间的大小，64M是块大小，所以空间大小是bs*count=1024MB
sudo fallocate -l 8G /mnt/8GB.swap
# 格式化成swap格式
sudo mkswap /mnt/8GB.swap
# 使用刚才创建的swap空间
sudo swapon /mnt/8GB.swap

# 验证swap是否打开
free -h

# 编译完成后关闭并删除swap
sudo swapoff /mnt/8GB.swap
sudo rm /mnt/8GB.swap

打开最高性能模式：

1 2	sudo nvpmodel -m 0 # on Xavier NX, use -m 2 instead (15W 6-core mode) sudo jetson_clocks

下载源码

# git clone --recursive --branch v1.8.0 http://github.com/pytorch/pytorch # 拉取1.8.0版本
# git submodule update --init --recursive  # 若上述拉取子模块的过程中失败。可以用该命令继续拉取
git clone --recursive --branch <version> http://github.com/pytorch/pytorch
cd pytorch

若拉取子模块没有问题，但是最后子模块文件夹下没有文件，可以通过删除文件夹继续执行拉取子模块命令解决

打补丁（防止在jetson上报错）
- JetPack 4.4.1 - pytorch-1.8-jetpack-4.4.1.patch
- JetPack 4.4.1 - pytorch-1-7-jetpack-4-4-1.patch
- JetPack 4.4 GA - pytorch-1.6-jetpack-4.4-GA.patch
- JetPack 4.4 DP - pytorch-diff-jetpack-4.4.patch
- JetPack 4.2 / 4.3 - pytorch-diff-jetpack-4.2.patch
1
2
cd pytorch
patch -p1 < pytorch-1.8-jetpack-4.4.1.patch
- 如果有.rej文件则表示打补丁失败，一般是代码冲突。需要打开.rej以及相应的.orig文件对比一下找到冲突在哪，解决掉冲突即可

配置构建选项

export USE_NCCL=0
#如果要启用OpenMPI后端，请跳过此设置
export USE_DISTRIBUTED=0
export USE_QNNPACK=0
export USE_PYTORCH_QNNPACK=0
export TORCH_CUDA_ARCH_LIST="5.3;6.2;7.2"
#没有前面的'v'，如1.3.0表示PyTorch v1.3.0
export PYTORCH_BUILD_VERSION=<version>
export PYTORCH_BUILD_NUMBER=1
export MAX_JOBS=4

注意，#符号不能加入

编译生成.whl文件

对于python2：

sudo apt-get install python-pip cmake libopenblas-dev
pip install -U pip

sudo pip install -U setuptools
sudo pip install -r requirements.txt

pip install scikit-build --user
pip install ninja --user

python setup.py bdist_wheel

对于python3：

sudo apt-get install python3-pip cmake libopenblas-dev

# pip3 install -r requirements.txt
pip install astunparse future numpy psutil pyyaml requests setuptools six typing_extensions dataclasses
pip3 install scikit-build
pip3 install ninja

python3 setup.py bdist_wheel

最后生成的路径为：./dist/torch-1.9.0-cp39-cp39-linux_aarch64.whl，通过pip install torch-1.9.0-cp39-cp39-linux_aarch64.whl即可安装

验证

# pytorch
import torch
print(torch.__version__)
print('CUDA available: ' + str(torch.cuda.is_available()))
print('cuDNN version: ' + str(torch.backends.cudnn.version()))
a = torch.cuda.FloatTensor(2).zero_()
print('Tensor a = ' + str(a))
b = torch.randn(2).cuda()
print('Tensor b = ' + str(b))
c = a + b
print('Tensor c = ' + str(c))
# torchvision
import torchvision
print(torchvision.__version__)

torchvision安装

注意torchvision与pytorch的对应关系：pytorch/vision: Datasets, Transforms and Models specific to Computer Vision，具体如下：

PyTorch v1.0 - torchvision v0.2.2
PyTorch v1.1 - torchvision v0.3.0
PyTorch v1.2 - torchvision v0.4.0
PyTorch v1.3 - torchvision v0.4.2
PyTorch v1.4 - torchvision v0.5.0
PyTorch v1.5 - torchvision v0.6.0
PyTorch v1.6 - torchvision v0.7.0
PyTorch v1.7 - torchvision v0.8.1
PyTorch v1.8 - torchvision v0.9.0
PyTorch v1.9 - torchvision v0.10.0

pip直接安装：

1	pip install torchvision

手动编译：

# 安装必备包
sudo apt-get install libjpeg-dev zlib1g-dev libpython3-dev libavcodec-dev libavformat-dev libswscale-dev
# clone对应项目源码 注意版本要对应（需要加v，如v0.10.0）
git clone --branch <version> https://github.com/pytorch/vision torchvision
cd torchvision
export BUILD_VERSION=0.x.0  # 0.x.0是torchvision的版本号
export MAX_JOBS=4  # 这种方式（parallel）似乎并不起作用
# https://stackoverflow.com/questions/60759623/python-setuptools-editable-install-with-parallel-build
python setup.py build -j4 --verbose  # 多核编译
python3 setup.py install --user
cd ../  # 尝试从构建目录加载 torchvision 将导致导入错误
# 下面这句在python2.7以及torchvision 0.5.0 以下需要
pip install 'pillow<7'

安装FCOS环境

项目地址：tianzhi0549/FCOS: FCOS: Fully Convolutional One-Stage Object Detection (ICCV’19)

配置：

# 创建新的虚拟环境（python需要>=3.7）
python3.8 -m venv fcos-venv
# 编写自动激活脚本（需要安装autoenv插件）
echo "source fcos-venv/bin/activate" > .env
# 激活虚拟环境
source fcos-venv/bin/activate
# 升级虚拟环境自带的pip
pip install --upgrade pip -i https://mirrors.aliyun.com/pypi/simple
# clone项目
git clone https://github.com/tianzhi0549/FCOS.git

安装依赖：

1	pip install ninja yacs cython matplotlib tqdm scikit-image

继续安装上一节编译好后的opencv：[链接到python虚拟环境](# 链接到python虚拟环境)

三、深度学习

参考链接：

Tutorials | NVIDIA Developer：官方总链接

Two Days to a Demo | NVIDIA Developer：动手实验

jetson-inference: Hello AI World guide to deploying deep-learning inference networks and deep vision primitives with TensorRT and NVIDIA Jetson：通过docker来快速部署

PyTorch for Jetson - version 1.8.0 now available：pytorch安装

1.jetson-inference项目

jetson-inference 是官方出品，用于快速上手的项目。通过使用NVIDIA TensorRT将神经网络有效地部署到Jetson上，并利用图形优化，内核融合和使用FP16/INT8精度的方式提高了性能

1.1环境搭建

前提是需要在JetPack上。一般来说通过SD卡安装的系统都已经满足该要求

该项目有两种方式进行搭建：

docker
直接编译源码再安装到系统中

docker方式

该方式需要下载位于 DockerHub 的容器（900M左右），国内可能比较慢，且需要JetPack的版本和容器的版本匹配。以下方法可以获得当前JetPack的版本：

1 2	head -n 1 /etc/nv_tegra_release # R32 (release), REVISION: 4.4, GCID: 23942405, BOARD: t210ref, EABI: aarch64, DATE: Fri Oct 16 19:44:43 UTC 2020

上方第二行为返回值，其版本为R32.4.4

通过以下方式安装并运行：

1
2
3

git clone --recursive https://github.com/dusty-nv/jetson-inference
cd jetson-inference
docker/run.sh

上述run.sh脚本会执行以下几件事：

自动检测JetPack版本并自动拉取docker image
自动挂载设备，以便在容器中使用：
- jetson-inference/data (存储网络模型，序列化的TensorRT引擎和测试镜像)
  - jetson-inference/data/images/test：建议将容器内部生成的图像保存在此处，对应容器中的路径为：images/test
- jetson-inference/python/training/classification/data (存储分类训练数据集)
- jetson-inference/python/training/classification/models (存储PyTorch训练的分类模型)
- jetson-inference/python/training/detection/ssd/data (存储检测训练数据集)
- jetson-inference/python/training/detection/ssd/models (存储PyTorch培训的检测模型)
- 摄像头节点
- 如果想将其他文件挂载进容器，可以通过传入如下参数：
  1
  docker/run.sh --volume /my/host/path:/my/container/path
根据选择自动下载模型权重文件

源码方式

执行以下命令即可在本机编译这个项目

sudo apt-get update
sudo apt-get install git cmake libpython3-dev python3-numpy
git clone --recursive https://github.com/dusty-nv/jetson-inference
cd jetson-inference
# 配置
mkdir build
cd build
cmake ../
#  cmake -D BUILD_DEPS=NO ../ # 配置时不检查依赖（不运行CMakePreBuild.sh下载模型）
# 下载模型（可选）
cd ../tools
./download-models.sh
# 安装PyTorch（可选，迁移学习用）
cd ../build
./install-pytorch.sh
# 编译工程
cd jetson-inference/build
make -j$(nproc)
sudo make install
sudo ldconfig

构建完毕后的镜像会在jetson-inference/build/aarch64中，执行make install会将其安装到系统中（ /usr/local/处），其结构如下：

|-build
   \aarch64
      \bin             生成示例二进制文件的位置
         \networks     网络模型的存储位置
         \images       测试图像的存储位置
      \include         头文件位置
      \lib             构建的lib库位置

make install后，python包jetson.inference 和 jetson.utils 也会一同安装到/usr/lib/python*/dist-packages/下

1.2推理

1.2.1分类（ImageNet）

1.2.2检测（DetectNet）

是用自带例子进行检测，能够在图像、视频、摄像头中检测，具体的输入输出流支持与切换可以参考官方文档： Camera Streaming and Multimedia。自带以下俩个例子：

detectnet.cpp (C++)
detectnet.py(Python)

命令行参数如下：

--network：修改模型文件，默认的检测模型为SSD-Mobilenet-v2
--overlay：以逗号为分隔符的一个组合，包括box, labels, conf, 和none，默认为--overlay=box,labels,conf，即显示边框、标签和置信度
--alpha：设置覆盖时使用的 alpha 混合值（默认值为 120）
--threshold：设置检测的最小阈值（默认值为 0.5）

1.2.3语义分割（SegNet）

1.3训练

2.tensorRT+yolov5

参考链接：

jkjung-avt/tensorrt_demos: TensorRT MODNet, YOLOv4, YOLOv3, SSD, MTCNN, and GoogLeNet

NVIDIA Deep Learning TensorRT Documentation

2.1 PyCUDA安装

为了使用TensorRT Python API，需要安装pycuda，版本为2019.1.2，从PyPI处下载对应的版本即可

通过pip仓库安装的方式会出问题：

# 设置环境变量 使用系统自带的nvcc
export CUDA_HOME=/usr/local/cuda  # 实际链接到了/usr/local/cuda-10.2
export PATH=$CUDA_HOME/bin:$PATH
export LD_LIBARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH
# 安装
pip install --global-option=build_ext --global-option="-I/usr/local/cuda/include" --global-option="-L/usr/local/cuda/lib64" pycuda --user -v

通过以下方式安装没有问题：

# 设置环境变量 使用系统自带的nvcc
export CUDA_HOME=/usr/local/cuda  # 实际链接到了/usr/local/cuda-10.2
export PATH=$CUDA_HOME/bin:$PATH
export LD_LIBARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH
# 安装
pip install 'pycuda<2021.1'

手动编译并安装pycuda（参考jkjung-avt/tensorrt_demos项目中的tensorrt_demos/ssd/install_pycuda.sh）：

# 设置环境变量 使用系统自带的nvcc
export PATH=$PATH:/usr/local/cuda-10.2/bin
# 安装相关依赖
sudo apt-get install build-essential python3-dev
sudo apt-get install libboost-python-dev libboost-thread-dev
pip install setuptools
# 从 https://pypi.org/project/pycuda/#files 处下载pycuda的源码包
tar xzvf pycuda-2019.1.2.tar.gz
cd pycuda-2019.1.2
# 配置
boost_pylib=$(basename /usr/lib/aarch64-linux-gnu/libboost_python*-py3?.so)  # libboost_python3-py36.so
boost_pylibname=${boost_pylib%.so}  # libboost_python3-py36
boost_pyname=${boost_pylibname/lib/}  # boost_python3-py36
python ./configure.py --python-exe=/home/jetson/mambaforge/envs/yolov5/bin/python --cuda-root=/usr/local/cuda --cudadrv-lib-dir=/usr/lib/aarch64-linux-gnu --boost-inc-dir=/usr/include --boost-lib-dir=/usr/lib/aarch64-linux-gnu --boost-python-libname=${boost_pyname} --boost-thread-libname=boost_thread --no-use-shipped-boost
# 编译
make -j4
python setup.py build
python setup.py install

注意更换python路径
可执行程序的路径可以通过where命令获取

2.2 cuDNN安装

NVIDIA CUDA 深度神经网络库 (cuDNN) 是经 GPU 加速的深度神经网络基元库。cuDNN 可大幅优化标准例程（例如用于前向传播和反向传播的卷积层、池化层、归一化层和激活层）的实施。

注意：jetson中默认已经安装cuDNN 8，无需再次安装

根据后面tensorRT的要求，需要安装cuDNN8.1.1，根据官方安装手册，先去NVIDIA cuDNN home page下载

# 解压
tar -xzvf cudnn-x.x-linux-x64-v8.x.x.x.tgz
# 将以下文件复制到 CUDA Toolkit 目录中
sudo cp cuda/include/cudnn*.h /usr/local/cuda/include 
sudo cp -P cuda/lib64/libcudnn* /usr/local/cuda/lib64 
sudo chmod a+r /usr/local/cuda/include/cudnn*.h /usr/local/cuda/lib64/libcudnn*

另一种直接通过apt安装：

1 2	sudo apt install libcudnn8 sudo apt install libcudnn8-dev

2.3 tensorRT安装

NVIDIA TensorRT 是用于高性能深度学习推理的 SDK。此 SDK 包含深度学习推理优化器和运行时环境，可为深度学习推理应用提供低延迟和高吞吐量。

注意：jetson中已经自带有tensorRT，通过dpkg -l | grep TensorRT命令可以查看，但是在conda的虚拟环境中不能使用，通过以下两种方式可以在conda中使用：
设置环境变量PYTHONPATH后，在激活conda环境即可载入原始python环境中自带的tensorRT
1
2
export PYTHONPATH=/usr/lib/python3.6/dist-packages:$PYTHONPATH
conda activate yolov5
从原始环境中拷贝
1
cp -r /usr/lib/python3.6/dist-packages/tensorrt* /home/jetson/mambaforge/envs/yolov5/lib/python3.6/site-packages

需要条件：

CUDA 10.2, 11.0 update 1, 11.1 update 1, or 11.2 update 1
cuDNN 8.1.1
TensorFlow 1.15.3以上
Pytorch 1.5.0测试通过
ONNX 1.6.0测试通过
python3（可选）
PyCUDA >= 2019.1.1（可选）

去官网下载tar方式的安装包，注意版本选择为TensorRT 7.2.3（后缀EA为Early Access），根据官方教程TensorRT 7.2.3 安装指南安装，选取tar的安装方式

各种包的对比：

deb、rpm包：

自动安装依赖

需要sudo

对于TensorRT安装在哪个位置没有灵活性

需要使用 Debian 或 RPM 软件包安装 CUDA Toolkit 和 cuDNN。

不允许同时安装一个以上的 TensorRT 次要版本

tar包：提供了更多的灵活性，例如同时安装多个版本的 TensorRT。但是需要确保已经安装了必要的依赖项，并且必须自己管理 LD_LIBRARY_PATH

zip包：是当前用于 Windows 的唯一选项。它不支持除 Windows 之外的任何其他平台。确保您已经安装了必要的依赖项

# 解压
tar xzvf TensorRT-7.2.3.4.Ubuntu-18.04.x86_64-gnu.cuda-10.2.cudnn8.1.tar.gz
# 将 TensorRT 中的 lib 目录的绝对路径添加到环境变量 LD_LIBRARY_PATH 中：
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/jetson/TensorRT-7.2.3.4/lib
# 安装 Python TensorRT
cd TensorRT-7.2.3.4/python
pip install tensorrt-7.2.3.4-cp36-none-linux_x86_64.whl
# 安装 Python UFF 轮文件。仅当您计划将 TensorRT 与 TensorFlow 结合使用时才需要这样做
cd TensorRT-7.2.3.4/uff
pip install uff-0.6.9-py2.py3-none-any.whl
which convert-to-uff # 检查
# 安装 Python graphsurgeon
cd TensorRT-7.2.3.4/graphsurgeon
pip install graphsurgeon-0.4.5-py2.py3-none-any.whl
# 安装 Python onnx-graphsurgeon
cd TensorRT-7.2.3.4/onnx_graphsurgeon
pip install onnx_graphsurgeon-0.2.6-py2.py3-none-any.whl

注意TensorRT的版本号与python的版本号
整个安装过程在conda中，所以无需区分pip2、pip3，同时无需使用sudo

2.4 模型转换

2.4.1 方案一（暂未通过）

参考链接：

TFLite, ONNX, CoreML Export · Issue #251 · ultralytics/yolov5

jkjung-avt/tensorrt_demos: TensorRT MODNet, YOLOv4, YOLOv3, SSD, MTCNN, and GoogLeNet

安装onnx：

1	mamba install onnx

编译libyolo_layer.so：

1 2	cd ${HOME}/project/tensorrt_demos/plugins make

模型转换 *.pt --> *.onnx --> tensorrt：

# 去yolov5仓库 将pt转成onnx
cd yolov5-master
python export.py --weights ../yolov5n_person.pt --include onnx --dynamic
# 回tensorrt_demos仓库 将onnx转成tensorrt
cd -
python onnx_to_tensorrt.py -m ../../yolov5n_person.onnx

如果上述步骤中出现错误：ImportError: /usr/lib/aarch64-linux-gnu/libstdc++.so.6: version `GLIBCXX_3.4.26’ not found ，则需要降低scipy版本：
1
mamba install scipy==1.3.1

实测上述问题不能在jetson nano上解决，需要通过设置LD_LIBRARY_PATH环境变量修改链接库到conda内部：

1
2
3

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/jetson/mambaforge/envs/yolov5/lib/
# 检查对应的库中是否存需要的符号：
strings /home/jetson/mambaforge/envs/yolov5/lib/libstdc++.so.6 | grep GLIBCXX

2.4.2 方案二

参考链接：

wang-xinyu/pytorchx: Implement popular deep learning networks in pytorch, used by tensorrtx.

参考上述链接中的tensorrtx/yolov5/README.md即可

采用YOLOv5s，推理时间在71ms左右，相比原来未经过tensorRT加速的网络快30ms左右

2.5 DeepStream

参考链接：

NVIDIA DeepStream SDK Developer Guide — DeepStream 6.0 Release documentation

DeepStream 是一个流分析工具包，用于构建 AI 驱动的应用程序。它将流数据作为输入——来自 USB/CSI 摄像头、来自文件的视频或通过 RTSP 的流，并使用人工智能和计算机视觉从像素中生成洞察力，以便更好地了解环境。 DeepStream SDK 可以成为许多视频分析解决方案的基础层，例如了解智慧城市中的交通和行人、医院中的健康和安全监控、零售中的自助结账和分析、制造工厂中的组件缺陷检测等。

DeepStream需要librdkafka 库，该库是 Apache Kafka 协议的 C 库实现，提供生产者、消费者和管理客户端。它的设计考虑了消息传递的可靠性和高性能，目前的数据是生产者每秒超过 100 万条消息，消费者每秒超过 300 万条消息。

根据上述DeepStream SDK的开发手册中的Quickstart Guide — DeepStream 6.0 Release documentation，安装jetson上的DeepStream 即可：

# 安装依赖
sudo apt install libssl1.0.0 libgstreamer1.0-0 gstreamer1.0-tools gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly gstreamer1.0-libav libgstrtspserver-1.0-0 libjansson4=2.11-1

# 安装librdkafka
git clone https://github.com/edenhill/librdkafka.git
# 配置、编译librdkafka
cd librdkafka
git reset --hard 7101c2310341ab3f4675fc565f64f0967e135a6a
./configure
make
sudo make install
# 将生成的库复制到 deepstream 目录：
sudo mkdir -p /opt/nvidia/deepstream/deepstream-6.0/lib
sudo cp /usr/local/lib/librdkafka* /opt/nvidia/deepstream/deepstream-6.0/lib

# 安装最新的 NVIDIA BSP
sudo vi /etc/apt/sources.list.d/nvidia-l4t-apt-source.list
# 在如下所示的 deb 命令中更改存储库名称和下载 URL：
deb https://repo.download.nvidia.com/jetson/common r32.6 main
deb https://repo.download.nvidia.com/jetson/t210 r32.6 main  # t210为Jetson Nano
# 更新
sudo apt update
sudo apt install --reinstall nvidia-l4t-gstreamer
# 使用以下命令安装最新的 L4T MM 和 L4T Core 软件包：
sudo apt install --reinstall nvidia-l4t-multimedia
sudo apt install --reinstall nvidia-l4t-core

# 安装 DeepStream SDK
# 方法一：使用SDK Manager（详见官方手册）
# 方法二：使用tar包
# 从https://developer.nvidia.com/deepstream_sdk_v6.0.0_jetsontbz2处下载tar包
# 输入以下命令以提取并安装 DeepStream SDK：
sudo tar -xvf deepstream_sdk_v6.0.0_jetson.tbz2 -C /
cd /opt/nvidia/deepstream/deepstream-6.0
sudo ./install.sh
sudo ldconfig
# 方法三：使用deb包
# 从https://developer.nvidia.com/deepstream-6.0_6.0.0-1_arm64deb处下载deb包
# 安装依赖
sudo apt install libgstrtspserver-1.0-0 libgstreamer-plugins-base1.0-dev
sudo dpkg -i ./deepstream-6.0_6.0.0-1_arm64.deb

使用官方用例测试：

1 2	cd /opt/nvidia/deepstream/deepstream-6.0/samples/configs/deepstream-app/ deepstream-app -c source8_1080p_dec_infer-resnet_tracker_tiled_display_fp16_nano.txt

如果发生Failed to create element ‘src_bin_muxer’错误，根据上述帖子中的内容，删除缓存即可：
1
rm ${HOME}/.cache/gstreamer-1.0/registry.aarch64.bin

2.5.1 deepstream-app 配置

汇总表：

组名	配置组
Application Group	与特定组件无关的应用程序配置
Tiled-display Group	应用程序中的平铺显示
Source Group	源属性。可以有多个来源。这些组必须命名为：[source0], [source1] …
Streammux Group	指定流复用组件（streammux）的属性和修改其行为
Preprocess Group	指定预处理组件的属性和修改行为
Primary GIE and Secondary GIE Group	指定主 GIE 的属性并修改其行为。指定辅助 GIE 的属性并修改其行为。这些组必须命名为：[secondary-gie0], [secondary-gie1] …
Tracker Group	指定对象跟踪器的属性并修改其行为
Message Converter Group	指定消息转换器组件的属性和修改其行为
Message Consumer Group	指定属性并修改消息使用者组件的行为。管道可以包含多个消息使用者组件。组必须命名为 [message-consumer0], [message-consumer1] …
OSD Group	指定属性并修改在每一帧上覆盖文本和矩形的屏幕显示 (on-screen display，OSD) 组件
Sink Group	指定表示输出（例如用于渲染、编码和文件保存的显示和文件）的接收器组件（sink components）的属性并修改其行为。管道可以包含多个接收器。组必须命名为：[sink0], [sink1] …
Tests Group	诊断和调试。这组是实验性的
NvDs-analytics Group	指定 nvdsanalytics 插件配置文件，并在应用程序中添加插件

Application Group

Key	Meaning	Type and Value	Example	Platforms
enable-perf-measurement	指示是否启用应用程序性能测量	Boolean	enable-perf-measurement=1	dGPU, Jetson
perf-measurement-interval-sec	采样和打印性能指标的时间间隔（以秒为单位）	Integer, >0	perf-measurement-interval-sec=10	dGPU, Jetson
gie-kitti-output-dir	应用程序以 KITTI 格式存储的主检测器输出的路径名	String	gie-kitti-output-dir=/home/ubuntu/kitti_data/	dGPU, Jetson
kitti-track-output-dir	应用程序以 KITTI 格式存储的跟踪器输出的路径名	String	kitti-track-output-dir=/home/ubuntu/kitti_data_tracker/	dGPU, Jetson

Tiled-display Group

Key	Meaning	Type and Value	Example	Platforms
enable	表示是否启用平铺显示。当用户设置enable=2时，第一个键值为link-to-emux=1的[sink]组应被链接到demuxer的src_[source_id]垫，其中source_id是在相应的[sink]组中设置的键值	Integer, 0 = disabled 1 = tiler-enabled 2 = tiler-and-parallel-demux-to-sink-enabled	enable=1	dGPU, Jetson
rows	平铺二维数组中的行数	Integer, >0	rows=5	dGPU, Jetson
columns	平铺二维数组中的列数	Integer, >0	columns=6	dGPU, Jetson
width	平铺二维阵列的宽度，以像素为单位	Integer, >0	width=1280	dGPU, Jetson
height	平铺二维阵列的高度，以像素为单位	Integer, >0	height=720	dGPU, Jetson
gpu-id	在多个 GPU 的情况下，组件将使用 GPU	Integer, ≥0	gpu-id=0	dGPU
nvbuf-memory-type	组件为输出缓冲区分配的内存类型。 0 (nvbuf-mem-default)：特定于平台的默认类型 1 (nvbuf-mem-cuda-pinned): pinned/host CUDA 内存 2（nvbuf-mem-cuda-device）：设备CUDA内存 3（nvbuf-mem-cuda-unified）：统一CUDA内存对于 dGPU：所有值均有效。对于 Jetson：只有 0（零）有效。	Integer, 0, 1, 2, or 3	nvbuf-memory-type=3	dGPU, Jetson

Source Group

DeepStream 应用程序支持多个同步源。对于每个源，必须在配置文件中添加一个单独的组，组名为 source%d 形式

Key	Meaning	Type and Value	Example	Platforms
enable	启用或禁用源	Boolean	enable=1	dGPU, Jetson
type	输入源类型；输入源的其他属性取决于此类型。 1：相机（V4L2） 2：URI 3：多个URI 4：RTSP 5：相机（CSI）（仅限Jetson）	Integer, 1, 2, 3, 4, or 5	type=1	dGPU, Jetson
uri	编码流的 URI。 URI 可以是文件、HTTP URI 或 RTSP 实时源。当 type=2 或 3 时有效。对于 MultiURI，%d 格式说明符也可用于指定多个源。应用程序从 0 迭代到 num-sources 以生成实际的 URI	String	uri=file:///home/ubuntu/source.mp4 uri=http://127.0.0.1/source.mp4 uri=rtsp://127.0.0.1/source1 uri=file:///home/ubuntu/source_%d.mp4	dGPU, Jetson
num-sources	输入源数量。仅当 type=3 时有效	Integer, ≥0	num-sources=2	dGPU, Jetson
intra-decode-enable	启用或禁用仅内部解码（intra-only decode）	Boolean	intra-decode-enable=1	dGPU, Jetson
num-extra-surfaces	除解码器给出的最小解码曲面外的曲面数。可用于管理管道中解码器输出缓冲区的数量	Integer, ≥0 and ≤24	num-extra-surfaces=5	dGPU, Jetson
gpu-id	在多个 GPU 的情况下，组件使用的 GPU	Integer, ≥0	gpu-id=1	dGPU
camera-id	要添加到元数据的输入源的唯一 ID（可选）	Integer, ≥0	camera-id=2	dGPU, Jetson
camera-width	从相机请求的帧宽度，以像素为单位。当type=1或5时有效	Integer, >0	camera-width=1920	dGPU, Jetson
camera-height	从相机请求的帧高度，以像素为单位。当type=1或5时有效	Integer, >0	camera-height=1080	dGPU, Jetson
camera-fps-n	指定相机请求的帧速率分数的分子部分，以帧/秒为单位。当 type=1 或 5 时有效	Integer, >0	camera-fps-n=30	dGPU, Jetson
camera-fps-d	指定相机请求的帧速率分数的分母部分，以帧/秒为单位。当 type = 1 或 5 时有效	Integer, >0	camera-fps-d=1	dGPU, Jetson
camera-v4l2-dev-node	V4L2设备节点编号。例如，/dev/video 为打开 V4L2 相机路径。当类型设置（源类型）为 1 时有效	Integer, >0	camera-v4l2-dev-node=1	dGPU, Jetson
latency	以毫秒为单位的抖动缓冲区大小；仅适用于 RTSP 流	Integer, ≥0	latency=200	dGPU, Jetson
camera-csi-sensor-id	摄像头模块的传感器 ID。当类型（源类型）为 5 时有效	Integer, ≥0	camera-csi-sensor-id=1	Jetson
drop-frame-interval	丢帧间隔。例如，5 表示解码器每五帧输出一次； 0 表示不丢帧。	Integer,	drop-frame-interval=5	dGPU, Jetson
cudadec-memtype	用于为类型 2,3 或 4 的源分配输出缓冲区的 CUDA 内存元素类型。不适用于 CSI 或 USB 相机源 0 (memtype_device)：使用 cudaMalloc() 分配的设备内存。 1 (memtype_pinned)：使用 cudaMallocHost() 分配的主机/固定内存。 2 (memtype_unified)：使用 cudaMallocManaged() 分配的统一内存。	Integer, 0, 1, or 2	cudadec-memtype=1	dGPU
nvbuf-memory-type	元素为 nvvideoconvert 的输出缓冲区分配的 CUDA 内存类型，对于类型 1 的源有用。 0（nvbuf-mem-default，特定于平台的默认值 1 (nvbuf-mem-cuda-pinned)：固定/主机 CUDA 内存。 2 (nvbuf-mem-cuda-device)：设备 CUDA 内存。 3 (nvbuf-mem-cuda-unified)：统一CUDA内存。对于 dGPU：所有值均有效。对于 Jetson：只有 0（零）有效。	Integer, 0, 1, 2, or 3	nvbuf-memory-type=3	dGPU,Jetson
select-rtp-protocol	用于 RTP 的传输协议。当 type（源类型）为 4 时有效 0：UDP + UDP 组播 + TCP 4：仅 TCP	Integer, 0 or 4	select-rtp-protocol=4	dGPU, Jetson
rtsp-reconnect-interval-sec	在强制重新连接之前从 RTSP 源接收到最后一个数据后等待的超时时间（以秒为单位）。将其设置为 0 将禁用重新连接。当 type（源类型）为 4 时有效	Integer, ≥0	rtsp-reconnect-interval-sec=60	dGPU, Jetson
rtsp-reconnect-attempts	尝试重新连接的最大次数。将其设置为 -1 意味着将无限尝试重新连接。当源类型为 4 且 rtsp-reconnect-interval-sec 为非零正值时有效。	Integer, ≥-1	rtsp-reconnect-attempts=2
smart-record	触发智能记录的方法。 0：禁用 1：只能通过云消息 2：云消息+本地事件	Integer, 0, 1 or 2	smart-record=1	dGPU, Jetson
smart-rec-dir-path	保存录制文件的目录路径。默认使用当前目录	String	smart-rec-dir-path=/home/nvidia/	dGPU, Jetson
smart-rec-file-prefix	录制视频的文件名前缀。默认情况下，Smart_Record 是前缀。对于唯一的文件名，必须为每个源提供唯一的前缀	String	smart-rec-file-prefix=Cam1	dGPU, Jetson
smart-rec-cache	以秒为单位的智能记录缓存大小	Integer, ≥0	smart-rec-cache=20	dGPU, Jetson
smart-rec-container	录制视频的容器格式。支持 MP4 和 MKV 容器	Integer, 0 or 1	smart-rec-container=0	dGPU, Jetson
smart-rec-start-time	从现在开始记录的提前秒数。例如。如果 t0 是当前时间，N 是开始时间（以秒为单位），这意味着录制将从 t0 – N 开始。显然要使其工作，视频缓存大小必须大于 N	Integer, ≥0	smart-rec-start-time=5	dGPU, Jetson
smart-rec-default-duration	如果未生成停止事件。此参数将确保在预定义的默认持续时间后停止录制	Integer, ≥0	smart-rec-default-duration=20	dGPU, Jetson
smart-rec-duration	以秒为单位的记录持续时间	Integer, ≥0	smart-rec-duration=15	dGPU, Jetson
smart-rec-interval	这是 SR 启动/停止事件生成的时间间隔（以秒为单位）	Integer, ≥0	smart-rec-interval=10	dGPU, Jetson

Streammux Group

[streammux] 组指定和修改 Gst-nvstreammux 插件的属性

Key	Meaning	Type and Value	Example	Platforms
gpu-id	GPU element is to use in case of multiple GPUs.	Integer, ≥0	gpu-id=1	dGPU
live-source	通知多路复用器（muxer），输入源是实时的	Boolean	live-source=0	dGPU, Jetson
buffer-pool-size	Muxer 输出缓冲池中的缓冲区数	Integer, >0	buffer-pool-size=4	dGPU, Jetson
batch-size	Muxer batch size.	Integer, >0	batch-size=4	dGPU, Jetson
batched-push-timeout	在第一个缓冲区可用后，推送批次（batch）后的超时时间（以微秒为单位），即使没有形成完整的批次（batch）	Integer, ≥−1	batched-push-timeout=40000	dGPU, Jetson
width	多路复用器（Muxer）输出宽度（以像素为单位）	Integer, >0	width=1280	dGPU, Jetson
height	多路复用器（Muxer）输出高度（以像素为单位）	Integer, >0	height=720	dGPU, Jetson
enable-padding	在通过添加黑带（black bands）进行缩放时是否保持源纵横比	Boolean	enable-padding=0	dGPU, Jetson
nvbuf-memory-type	组件为输出缓冲区分配的 CUDA 内存类型。 0（nvbuf-mem-default，特定于平台的默认值 1 (nvbuf-mem-cuda-pinned)：固定/主机 CUDA 内存。 2 (nvbuf-mem-cuda-device)：设备 CUDA 内存。 3 (nvbuf-mem-cuda-unified)：统一CUDA内存。对于 dGPU：所有值均有效。对于 Jetson：只有 0（零）有效。	Integer, 0, 1, 2, or 3	nvbuf-memory-type=3	dGPU
attach-sys-ts-as-ntp	对于实时源，当流式传输 RTSP 时，混合缓冲区（muxed buffer）应将关联的 NvDsFrameMeta->ntp_timestamp 设置为系统时间或服务器的 NTP 时间。如果设置为 1，系统时间戳将作为 ntp 时间戳附加。如果设置为 0，则将附加来自 rtspsrc 的 ntp 时间戳（如果可用）。	Boolean	attach-sys-ts-as-ntp=0	dGPU, Jetson
config-file-path	此key仅对新streammux有效。请参阅插件手册“New Gst nvstreammux”部分了解更多信息。mux配置文件的绝对或相对（DS配置文件位置）路径	String	config-file-path=config_mux_source30.txt	dGPU, Jetson
sync-inputs	在批处理之前对输入帧进行时间同步	Boolean	sync-inputs=0 (default)	dGPU, Jetson
max-latency	实时模式下的额外延迟，以允许上游花费更长的时间来为当前位置（以纳秒为单位）生成缓冲区	Integer, ≥0	max-latency=0 (default)	dGPU, Jetson

Gst-nvstreammux New (Beta) — DeepStream 6.0 Release documentation (nvidia.com)

Preprocess Group

[pre-process] 组用于在管道中添加 nvdspreprocess 插件。仅支持主 GIE 的预处理

Key	Meaning	Type and Value	Example	Platforms
enable	Enables or disables the plugin.	Boolean	enable=1	dGPU, Jetson
config-file	Configuration file path for nvdspreprocess plugin	String	config-file=config_preprocess.txt	dGPU, Jetson

Gst-nvdspreprocess (Alpha) — DeepStream 6.0 Release documentation (nvidia.com)

Primary GIE and Secondary GIE Group

DeepStream应用程序支持多个二级GIE（GPU Inference Engines）。对于每个次要GIE，必须将名为 secondary-gie%d 的单独组添加到配置文件中

Key	Meaning	Type and Value	Example	Platforms/ GIEs*
enable	是否必须启用主 GIE	Boolean	enable=1	dGPU, Jetson Both GIEs
gie-unique-id	要分配给 nvinfer 实例的唯一组件 ID。用于标识实例生成的元数据	Integer, >0	gie-unique-id=2	Both
gpu-id	在多个 GPU 的情况下，组件将使用的 GPU	Integer, ≥0	gpu-id=1	dGPU, Both GIEs
model-engine-file	模型预生成序列化引擎文件的绝对路径名	String	model-engine-file=…/…/ models/Primary_Detector/resnet10. caffemodel_b4_int8.engine	Both GIEs
nvbuf-memory-type	CUDA 内存元素的类型是分配给输出缓冲区。 0 (nvbuf-mem-default)：特定于平台的默认值 1 (nvbuf-mem-cuda-pinned): pinned/host CUDA 内存 2（nvbuf-mem-cuda-device）：设备CUDA内存 3（nvbuf-mem-cuda-unified）：统一CUDA内存对于 dGPU：所有值均有效。对于 Jetson：只有 0（零）有效。	Integer, 0, 1, 2, or 3	nvbuf-memory-type=3	dGPU, Jetson Primary GIE
config-file	指定 Gst-nvinfer 插件属性的配置文件的路径名。它可能包含此表中描述的任何属性，但配置文件本身除外。属性必须在名为 [property] 的组中定义。有关参数的更多详细信息，请参阅 DeepStream 4.0 插件手册中的“Gst-nvinfer 文件配置规范”。	String	config-file=¬/home/-ubuntu/-config_infer_resnet.txt For complete examples, see the sample file samples/¬configs/-deepstream-app/-config_infer_resnet.txt or the deepstream-test2 sample application.	dGPU, Jetson Both GIEs
batch-size	在一个批次中要一起推断的帧（P.GIE）/对象（S.GIE）的数量	Integer, >0 Integer, >0	batch-size=2	dGPU, Jetson Both GIEs
interval	跳过推理的连续批次数	Integer, >0 Integer, >0	interval=2	dGPU, Jetson Primary GIE
bbox-border-color	特定类 ID 的对象的边框颜色，以 RGBA 格式指定。key的格式必须为 bbox-border-color。可以为多个类 ID 多次标识此属性。如果未为类 ID 标识此属性，则不会为该类 ID 的对象绘制边框。	R:G:B:A Float, 0≤R,G,B,A≤1	bbox-border-color2= 1;0;0;1 (Red for class-id 2)	dGPU, Jetson Both GIEs
bbox-bg-color	特定类 ID 的对象上绘制的框的颜色，采用 RGBA 格式。key的格式必须为 bbox-bg-color。此属性可以多次用于多个类 ID。如果它不用于类 ID，则不会为该类 ID 的对象绘制框。	R:G:B:A Float, 0≤R,G,B,A≤1	bbox-bg-color3=-0;1;0;0.3 (Semi-transparent green for class-id 3)	dGPU, Jetson Both GIEs
operate-on-gie-id	GIE 的唯一 ID，此 GIE 将在其元数据 (NvDsFrameMeta) 上运行	Integer, >0	operate-on-gie-id=1	dGPU, Jetson Secondary GIE
operate-on-class-ids	此 GIE 必须在其上运行的父 GIE 的类 ID。使用 operation-on-gie-id 指定父 GIE。	Semicolon separated integer array	operate-on-class-ids=1;2 (operate on objects with class IDs 1, 2 generated by parent GIE)	dGPU, Jetson Secondary GIE
infer-raw-output-dir	Pathname of an existing directory in which to dump the raw inference buffer contents in a file.	String	infer-raw-output-dir=/home/ubuntu/infer_raw_out	dGPU, Jetson Both GIEs
labelfile-path	Pathname of the labelfile.	String	labelfile-path=…/…/models/Primary_Detector/labels.txt	dGPU, Jetson Both GIEs
plugin-type	Plugin to use for inference. 0: nvinfer (TensorRT) 1: nvinferserver (Triton inference server)	Integer, 0 or 1	plugin-type=1	dGPU, Jetson Both GIEs
input-tensor-meta	Use preprocessed input tensors attached as metadata by nvdspreprocess plugin instead of preprocessing inside the nvinfer.	Integer, 0 or 1	input-tensor-meta=1	dGPU, Jetson, Primary GIE

Gst-nvinfer — DeepStream 6.0 Release documentation (nvidia.com)