NX_README
developer-guide:
https://docs.nvidia.com/deeplearning/tensorrt/developer-guide/index.html
套件包含清单
NVIDIA Jetson Xavier NX模块及载板
19v电源适配器
802.11无线网卡及蓝牙模块（安装在载板下方）
说明书
需要准备
sd卡（大于16G，建议64G以上的告诉内存卡）
支持DP或HDMI接口的显示屏
USB键鼠
1：烧录步骤
①：下载SD卡镜像
https://developer.nvidia.com/jetson-nx-developer-kit-sd-card-image
②：下载烧录软件
http://file.ncnynl.com/rpi/Win32DiskImager-0.9.5-install.exe
烧录到sd卡上
③：烧录好的SD卡插入NX的卡槽，然后开机测试
2：版本检查
我的NX开发板的刷机版本为Jetpack4.4.0
1、驱动版本：head -n 1 /etc/nv_tegra_release
# R32 (release), REVISION: 4.2, GCID: 20074772, BOARD: t186ref, EABI: aarch64, DATE: Thu Apr 9 01:26:40 UTC 2020
2、内核版本：uname -r
4.9.140-tegra
3、操作系统：lsb_release -i -r
Distributor ID: Ubuntu
Release: 18.04
4、CUDA版本：nvcc -V
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2019 NVIDIA Corporation
Built on Wed_Oct_23_21:14:42_PDT_2019
Cuda compilation tools, release 10.2, V10.2.89
5、cuDNN版本：dpkg -l libcudnn8
Desired=Unknown/Install/Remove/Purge/Hold
| Status=Not/Inst/Conf-files/Unpacked/halF-conf/Half-inst/trig-aWait/Trig-pend
|/ Err?=(none)/Reinst-required (Status,Err: uppercase=bad)
||/ Name Version Architecture Description
+++-==================-==============-==============-=========================================
ii libcudnn8 8.0.0.145-1+cu arm64 cuDNN runtime libraries
6、opencv版本：dpkg -l libopencv
Desired=Unknown/Install/Remove/Purge/Hold
| Status=Not/Inst/Conf-files/Unpacked/halF-conf/Half-inst/trig-aWait/Trig-pend
|/ Err?=(none)/Reinst-required (Status,Err: uppercase=bad)
||/ Name Version Architecture Description
+++-==================-==============-==============-=========================================
ii libopencv 4.1.1-2-gd5a58 arm64 Open Computer Vision Library
7、Tensorrt版本： dpkg -l tensorrt
dpkg -l | grep TensorRT
Desired=Unknown/Install/Remove/Purge/Hold
| Status=Not/Inst/Conf-files/Unpacked/halF-conf/Half-inst/trig-aWait/Trig-pend
|/ Err?=(none)/Reinst-required (Status,Err: uppercase=bad)
||/ Name Version Architecture Description
+++-==================-==============-==============-=========================================
ii tensorrt 7.1.0.16-1+cud arm64 Meta package of TensorRT
3：CUDA环境配置
配置一下环境
export PATH=/usr/local/cuda/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH
export CUDA_HOME=$CUDA_HOME:/usr/local/cuda
source ~/.bashrc
查看nvcc
nvcc -V
4：Jtop python安装
NX开发套件中预装的python版本为2.7，安装了ython3，直接终端输入：
sudo apt-get install python3-pip python3-dev
//接着将pip升级为最新版
python3 -m pip install --upgrade pip #升级pip
安装Jtop进行内存/CPU/GPU监视
sudo pip install jetson-stats
sudo systemctl restart jetson_stats.service
sudo jtop
5：NX风扇控制
Xavier NX的风扇在系统内核中有一套自动控制温度和转速的算法，大约在40度左右的时候会自动开启风扇进行散热，在核心温度大约低于39度时候会自动关闭散热风扇。
设置模式：
15W模型，风扇会自己转。。
设置命令：
sudo sh -c 'echo 140 > /sys/devices/pwm-fan/target_pwm'
命令行中数字位数140即代表了风扇的PWM占空比参数。其区间为0～255，0即代表了风扇完全停止，255代表了风扇火力全开。实际上在日常使用过程中我倾向于使用100～150的占空比，也就是40%～60%左右。因为过低风扇散热无力，过高了风扇噪音快赶上台式机了，听起来会比较烦人。除了重度编译，运行较大网络吃满资源，还是用不到255的占空比的。
6：NX换源
换源原则：
注意处理器是aarch64架构的Ubuntu 18.04.2 LTS系统类型的，要使用与之匹配的源 。
添加国内清华源，首先备份原本的source.list文件
sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak #为防止误操作后无法恢复，先备份原文件sources.list
sudo gedit /etc/apt/sources.list
然后删除所有内容，复制下列内容到到sources.list后保存
deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic main multiverse restricted universe
deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-security main multiverse restricted universe
deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-updates main multiverse restricted universe
deb http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-backports main multiverse restricted universe
deb-src http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic main multiverse restricted universe
deb-src http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-security main multiverse restricted universe
deb-src http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-updates main multiverse restricted universe
deb-src http://mirrors.tuna.tsinghua.edu.cn/ubuntu-ports/ bionic-backports main multiverse restricted universe
最后打开终端输入
sudo apt-get update
6：tensorflow安装
在安装tnesorflow之前，一定要找到自己板卡刷机中Jetpack+python所对应的tensorflow版本，
这个最好去nvidia官网的社区去查一下，因为版本不对，即使你安装上。
附上关于Python 3.6+JetPack4.4的官方解答链接
https://forums.developer.nvidia.com/t/official-tensorflow-for-jetson-agx-xavier/65523
7：USB摄像头检测工具的安装
大部分摄像头不支持Linux系统，可以通过安装cheese脚本来激活Ubuntu自带的摄像头驱动（UVC），只需通过一条简单的指令即可安装cheese脚本：
sudo apt-get install cheese
安装完成后，在终端输入
cheese
即可打开usb摄像头。此时，摄像头就可以满足即插即用了。
如果想要查看当前插入的摄像头的设备编号，可在终端输入
ls /dev/video*
8：jetson-inference例程
参考：
https://blog.csdn.net/zbb297918657/article/details/106432773
官方：
提供的jetson_inference项目文件的Github
jetson-inference下载地址：https://github.com/dusty-nv/jetson-inference
9：例程：
jetpack 4.2体验 在jetson tx2上使用python3调用tensorRT推理tensorflow模型
https://blog.csdn.net/weixin_43842032/article/details/88753724
tensorrt路径在：
/usr/src/tensorrt
10：安装caffe：
如果需要插件，则需要源码加插件转引擎
https://blog.csdn.net/u012614287/article/details/81537743
常规模型转trt，不需要NX装源码
11：测试caffe、ONNX转的模型
出现
CMakeFiles/traffic_det_reg_caffe_trt.dir/src/TrafficDetection.cpp.o:
In function onnxToTRTModel(std::__cxx11::basic_string<char,
std::char_traits, std::allocator > const&,
std::__cxx11::basic_string<char, std::char_traits,
std::allocator > const&, nvinfer1::ICudaEngine*&, int const&)’:
TrafficDetection.cpp:(.text+0x1357): undefined reference
tocreateNvOnnxParser_INTERNAL’
cmakelist添加：
#/home/name/TensorRT-7.1.3.4/lib/libnvinfer.so
#/home/name/TensorRT-7.1.3.4/lib/libnvinfer_plugin.so
#/home/name/TensorRT-7.1.3.4/lib/libnvparsers.so
-lnvonnxparser
12：调用NX的DLA
Jetson Xavier NX 的核心竞争力是其机器推理性能。
除了 CPU 和 GPU，Jetson Xavier NX 内还设计有DLA（Deep Learning Accelerator，深度学习加速器）和 PVA（Programmable Vision Accelerator，可编程视觉加速器）单元。Volta GPU 与 DLA 核心的结合，使其在低功耗平台上构筑了强大的处理能力。
为了展示该系统的机器学习推理能力，NVIDIA 为 Jetson 平台提供了大量软件开发套件以及手动调整框架，预先为开发者做了大量繁重的准备工作，使他们能充分利用 GPU 中的 DLA 单元。
有些层DLA不支持，则会回传GPU进行处理，整体来看，节约了GPU资源，但是DLA跑模型速度会慢一倍左右
//sample data:
inline void enableDLA(IBuilder* builder, IBuilderConfig* config, int useDLACore, bool allowGPUFallback = true)
{
if (useDLACore >= 0)
{
if (builder->getNbDLACores() == 0)
{
std::cerr << "Trying to use DLA core " << useDLACore << " on a platform that doesn't have any DLA cores"
<< std::endl;
assert("Error: use DLA core on a platfrom that doesn't have any DLA cores" && false);
}
if (allowGPUFallback)
{
config->setFlag(BuilderFlag::kGPU_FALLBACK);
}
if (!builder->getInt8Mode() && !config->getFlag(BuilderFlag::kINT8))
{
// User has not requested INT8 Mode.
// By default run in FP16 mode. FP32 mode is not permitted.
builder->setFp16Mode(true);
config->setFlag(BuilderFlag::kFP16);
}
config->setDefaultDeviceType(DeviceType::kDLA);
config->setDLACore(useDLACore);
config->setFlag(BuilderFlag::kSTRICT_TYPES);
}
}
//转模型的时候：
// Build the engine
builder->setMaxBatchSize(BATCH_SIZE);
//config->setMaxWorkspaceSize(1_GiB);
config->setMaxWorkspaceSize(1 * (1 << 20)); // 16MB
config->setFlag(nvinfer1::BuilderFlag::kFP16);
std::cout << "**********************************DLA***********************" << std::endl;
// nx /usr/src/tensorrt/samples/common/common.h
std::cout << "start dla." << std::endl;
config->setFlag(nvinfer1::BuilderFlag::kGPU_FALLBACK);
config->setDefaultDeviceType(nvinfer1::DeviceType::kDLA);
config->setDLACore(true);
config->setFlag(nvinfer1::BuilderFlag::kSTRICT_TYPES);
std::cout << "start building engine" << std::endl;
engine = builder->buildEngineWithConfig(*network, *config);
std::cout << "build engine done" << std::endl;
assert(engine);
parser->destroy();
nvinfer1::IHostMemory *data = engine->serialize();
std::ofstream file;
file.open(filename, std::ios::binary | std::ios::out);
std::cout << "writing engine file..." << std::endl;
file.write((const char *)data->data(), data->size());
std::cout << "save engine file done" << std::endl;
file.close();
network->destroy();
builder->destroy();
//调用的时候：
// deserialize the engine
IRuntime* runtime = createInferRuntime(gLogger);
assert(runtime != nullptr);
if (gArgs.useDLACore >= 0)
{
runtime->setDLACore(gArgs.useDLACore);
}
ICudaEngine* engine = runtime->deserializeCudaEngine(trtModelStream->data(
13：NX上测试mmpose
可结合场景，应用于事件判断：
人和车，人分析等
行人检测后，再进行定位，，单个人17个关键点定位的耗时：
nx
前处理： 1.1 ms
推理： 31 ms
后处理： 0.6 ms
单帧耗时： 32.7 ms
鼻子-0, 脖子-1，右肩-2，右肘-3，右手腕-4，左肩-5，左肘-6，左手腕-7，右臀-8，右膝盖-9，右脚踝-10，左臀-11，左膝盖-12，左脚踝-13，右眼-14，左眼-15，有耳朵-16，左耳朵-17，背景-18.
可视化恢复到原图显示方法：
// prepareImage
std::vector<float> prepareImage(std::vector<cv::Mat> &vec_img) {
std::vector<float> result(BATCH_SIZE * IMAGE_WIDTH * IMAGE_HEIGHT * INPUT_CHANNEL);
float *data = result.data();
for (const cv::Mat &src_img : vec_img)
{
if (!src_img.data)
continue;
float ratio = std::min(float(IMAGE_WIDTH) / float(src_img.cols), float(IMAGE_HEIGHT) / float(src_img.rows));
cv::Mat flt_img = cv::Mat::zeros(cv::Size(IMAGE_WIDTH, IMAGE_HEIGHT), CV_8UC3);
cv::Mat rsz_img;
cv::resize(src_img, rsz_img, cv::Size(), ratio, ratio);
rsz_img.copyTo(flt_img(cv::Rect(0, 0, rsz_img.cols, rsz_img.rows)));
flt_img.convertTo(flt_img, CV_32FC3, 1.0 / 255);
//HWC TO CHW
std::vector<cv::Mat> split_img(INPUT_CHANNEL);
cv::split(flt_img, split_img);
int channelLength = IMAGE_WIDTH * IMAGE_HEIGHT;
for (int i = 0; i < INPUT_CHANNEL; ++i)
{
split_img[i] = (split_img[i] - img_mean[i]) / img_std[i];
memcpy(data, split_img[i].data, channelLength * sizeof(float));
data += channelLength;
}
}
return result;
}
// postProcess
std::vector<std::vector<KeyPoint>> postProcess(const std::vector<cv::Mat> &vec_Mat, float *output, const int &outSize) {
std::vector<std::vector<KeyPoint>> vec_key_points;
int feature_size = IMAGE_WIDTH * IMAGE_HEIGHT / 16;
int index = 0;
for (const cv::Mat &src_img : vec_Mat) {
std::vector<KeyPoint> key_points = std::vector<KeyPoint>(num_key_points);
float ratio = std::max(float(src_img.cols) / float(IMAGE_WIDTH), float(src_img.rows) / float(IMAGE_HEIGHT));
float *current_person = output + index * outSize;
for (int number = 0; number < num_key_points; number++) {
float *current_point = current_person + feature_size * number;
auto max_pos = std::max_element(current_point, current_point + feature_size);
key_points[number].prob = *max_pos;
float x = (max_pos - current_point) % (IMAGE_WIDTH / 4) + (*(max_pos + 1) > *(max_pos - 1) ? 0.25 : -0.25);
float y = (max_pos - current_point) / (IMAGE_WIDTH / 4) + (*(max_pos + IMAGE_WIDTH / 4) > *(max_pos - IMAGE_WIDTH / 4) ? 0.25 : -0.25);
key_points[number].x = int(x * ratio * 4);
key_points[number].y = int(y * ratio * 4);
key_points[number].number = number;
}
vec_key_points.push_back(key_points);
index++;
}
return vec_key_points;
}
13：Cuda编程后处理
1、例如：
分割网络，可行驶区域检测。
输入512×512×3，输出512×512×2
核函数设置
dim3 dimBlock(64);
dim3 dimGrid((512 + 63) / 64,512,batch_size);
getmax<<<dimGrid, dimBlock>>>(tensor, outputDevice,512);
并行运行，求解最大值就是可行驶区域的点：
__global__ void getmax(float *input, uchar *result, int feature_w) {
int h = threadIdx.x + blockDim.x * blockIdx.x;
int num_class = blockIdx.y;
int batch_size = blockIdx.z;
int n = batch_size * num_class * gridDim.y + num_class * feature_w + h;
if (h < i) {
if( input[n * 2] > input[n * 2 + 1]){
result[n] = 0;
}
else{
result[n] = 255;
}
同一像素两个类别数据是挨着的，
如 0 1
2 3
4 5
6 7
. .
2n 2n+1
所以 input[n * 2] input[n * 2 + 1]
一共需要的线程数量，就是 h * w *batch_size
为了加速，每个grid里面64个线程
2 、例如：
利用cuda编程处理，yoloV5的前处理和后处理，
COCO数据集进行数据获取 output_xywh_pro_index
{
int ntypes = 25200 * 6 * sizeof(float);
cudaMalloc((void **)&output_xywh_pro_index, 1 * 25200 * 6 * sizeof(float));
CHECK(cudaGetLastError());
Detforward_gpu_box(static_cast<float *>(buffers[1]), output_xywh_pro_index);
cudaMemcpyAsync(out_result, output_xywh_pro_index, ntypes, cudaMemcpyDeviceToHost);
std::cout << "Memcpy ok." << std::endl;
boxes = postProcess_gpu(src, out_result, outSize);
}
void Detforward_gpu_box(const float *intput,
float *output_xywh_pro_index)
{
std::cout << "Into Detforward_gpu box ." << std::endl;
// if (1)
// {
dim3 dimBlock(1);
dim3 dimGrid(25200);
YoloProposal_box<<<dimGrid, dimBlock>>>(intput, 25200, output_xywh_pro_index);
cudaError_t cudaStatus;
cudaStatus = cudaGetLastError();
if (cudaStatus != cudaSuccess)
{
fprintf(stderr, "Kernel launch failed: %s\n", cudaGetErrorString(cudaStatus));
}
std::cout << "set kernel ok." << std::endl;
}
__global__ void YoloProposal_box(const float *tensor, const int FEATURE_SIZE_NUM, float *output)
//__global__ void YoloProposal_box(const float *tensor)
{
int start_indx = 1;
if (true)
{
// int idx = (blockIdx.x + blockIdx.y * gridDim.x) * blockDim.x + threadIdx.x;
int idx = blockIdx.x;
// printf(" idx:%d", idx);
if (idx > 25200)
{
return;
}
float cx = tensor[idx * 85 + 0];
float cy = tensor[idx * 85 + 1];
float w = tensor[idx * 85 + 2];
float h = tensor[idx * 85 + 3];
float score = tensor[idx * 85 + 4];
// if (idx > 25190)
// {
// printf("*** gpu *** x,y,w,h: %d %f %f %f %f:\n", idx, cx, cy, w, h); // 0 - 255
// }
float objProb;
int index;
for (int k = 0; k < 80; k++)
{
float prob_class = tensor[idx * 85 + 5 + k];
// printf(" gpu %f %f %f %f\n:", cx, cy, w, h); // 0 - 255
if (max(prob_class, objProb) == prob_class)
{
index = k;
objProb = prob_class;
}
output[idx * 6 + 0] = cx;
output[idx * 6 + 1] = cy;
output[idx * 6 + 2] = w;
output[idx * 6 + 3] = h;
output[idx * 6 + 4] = objProb * score;
output[idx * 6 + 5] = index;
}
__syncthreads();
}
14：Paddle inference调用trt算子
https://github.com/PaddlePaddle/Paddle-Inference-Demo
https://paddle-inference.readthedocs.io/en/latest
飞桨开源框架项目地址：
GitHub:
https://github.com/PaddlePaddle/Paddle
Gitee:
https://gitee.com/paddlepaddle/Paddle
当模型加载后，模型表示为由算子节点组成的拓扑图。如果在运行前指定了TRT子图模式，那在模型图分析阶段，Paddle Inference会找出能够被TRT运行的算子节点，同时将这些互相链接的OP融合成一个子图并用一个TRT 算子代替，运行期间如果遇到TRT 算子，则调用TRT引擎执行。
在Paddle 1.8 版本中，对Ernie模型进行了TRT子图的集成，支持动态尺寸的输入功能。
当预测期间，被TRT 引擎执行的算子会在初始化期间运行所有候选计算内核（kernel），并根据根据输入的尺寸选择出最佳的那一个出来，保证了模型的最佳推理性能。
/usr/bin/ld: cannot find -lcudart
collect2: error: ld returned 1 exit status
sudo ln -s /usr/local/cuda/lib64/libcudart.so /usr/lib/libcudart.so
1785
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
