1. 分辨率（YOLOv5P5、YOLOX）= (640×640)，(YOLOv5P6) = (1280×1280)
2. 最大批处理大小 = 16
3. 预处理 + 推理 + 后处理
4. CUDA 10.2，cuDNN 8.2.2.26，TensorRT 8.0.1.6
5. RTX 2080 Ti
6. 测试次数：取100次结果的平均值，但排除首次预热运行
7. 测试日志：workspace/perf.result.std.log
8. 测试代码：src/application/app_yolo.cpp
9. 测试图像：位于workspace/inference目录下的6张图片
   • 分别为810×1080、500×806、1024×684、550×676、1280×720、800×533分辨率
10. 测试方法：加载6张图片，对这6张图片进行推理，重复100次。注意每张图片都需要进行预处理和后处理。

• 亮点： 在精度无损的情况下，比上述结果快约0.5毫秒。具体来说，我们移除了Focus层及部分转置节点等，并将其改用CUDA内核函数实现，其余部分保持不变。
• 测试日志： workspace/perf.result.std.log
• 测试代码： src/application/app_yolo_fast.cpp
• 提示： 可以参考下载的ONNX文件进行修改。如有任何疑问，欢迎通过各种方式联系。
• 结论： 本工作的核心思想是优化预处理和后处理流程。若使用YOLOX或YOLOv5的小型版本，该优化可能会有所帮助。

1. VSCode（强烈推荐！）
2. 配置 cuDNN、CUDA、TensorRT 8.0 和 Protocol Buffers 的路径。
3. 在 Makefile 或 CMakeLists.txt 中配置与你的 NVIDIA 显卡匹配的计算能力：
   • 例如：-gencode=arch=compute_75,code=sm_75。如果你使用的是 3080Ti，则应为 gencode=arch=compute_86,code=sm_86。
   • GPU 计算能力参考表： https://developer.nvidia.com/cuda-gpus#compute
4. 在 .vscode/c_cpp_properties.json 中配置库路径。
5. CUDA 版本：CUDA 10.2
6. cuDNN 版本：cudnn 8.2.2.26。注意需要同时下载开发文件（.h 文件）和运行时文件（.so 文件）。
7. TensorRT 版本：tensorRT-8.0.1.6-cuda10.2
8. Protocol Buffers 版本（用于 ONNX 解析器）：protobuf v3.11.4
   • 如果使用其他版本，请参考……
   • 下载链接：https://github.com/protocolbuffers/protobuf/tree/v3.11.4
   • 下载后编译，并将 Makefile/CMakeLists.txt 中的路径替换为新的 protobuf 3.11.4 路径。

• CMake：
  • mkdir build && cd build
  • cmake ..
  • make yolo -j8
• Makefile：
  • make yolo -j8

• 编译并安装
  • Makefile：
    • 在 Makefile 中设置 use_python := true
  • CMakeLists.txt：
    • 在 CMakeLists.txt 中设置 set(HAS_PYTHON ON)
  • 输入 make pyinstall -j8
  • 编译后的文件位于 python/pytrt/libpytrtc.so

1. 请查看 lean/README.md 以获取详细的依赖项信息。

2. 在 TensorRT.vcxproj 中，将 <Import Project="$(VCTargetsPath)\BuildCustomizations\CUDA 10.0.props" /> 替换为你自己的 CUDA 路径。

3. 在 TensorRT.vcxproj 中，将 <Import Project="$(VCTargetsPath)\BuildCustomizations\CUDA 10.0.targets" /> 替换为你自己的 CUDA 路径。

4. 在 TensorRT.vcxproj 中，将 <CodeGeneration>compute_61,sm_61</CodeGeneration> 替换为你自己的计算能力。

   • 参考 https://developer.nvidia.com/cuda-gpus#compute 上的表格

5. 配置你的依赖项，或将它们下载到 /lean 文件夹中。配置 VC++ 目录（包含目录和引用）。

6. 配置环境变量，在“调试”->“环境”中进行设置。

7. 编译并运行示例，有三种选项可供选择。

1. 编译 pytrtc.pyd。在 Visual Studio 中选择 Python 进行编译。
2. 复制 dll 文件并执行 python/copy_dll_to_pytrt.bat。
3. 在 python 目录下通过 python test_yolov5.py 执行示例。

• 如果需要安装，切换到目标环境（例如你的 conda 环境），然后运行 python setup.py install，之后再按照步骤 1 和 2 操作。
• 编译后的文件位于 python/pytrt/libpytrtc.pyd。

• 在 onnx/make_pb.sh 中，将 protoc 的路径 protoc=/data/sxai/lean/protobuf3.11.4/bin/protoc 替换为你自己版本的 protoc。

# 在终端中进入 /onnx 路径
cd onnx

# 执行命令生成 pb 文件
bash make_pb.sh

• CMake：
  • 将 CMakeLists.txt 中的 set(PROTOBUF_DIR "/data/sxai/lean/protobuf3.11.4") 替换为你所用 protoc 的相同路径。

mkdir build && cd build
cmake ..
make yolo -j64

• Makefile：
  • 将 Makefile 中的 lean_protobuf := /data/sxai/lean/protobuf3.11.4 替换为你所用 protoc 的相同路径。

make yolo -j64

• 默认是 TensorRT 8.x

1. 将 onnx_parser_for_7.x/onnx_parser 替换为 src/tensorRT/onnx_parser
   • bash onnx_parser/use_tensorrt_7.x.sh
2. 配置 Makefile/CMakeLists.txt 中指向 TensorRT 7.x 的路径。
3. 执行 make yolo -j64

• 默认是 TensorRT 8.x

1. 将 onnx_parser_for_8.x/onnx_parser 替换为 src/tensorRT/onnx_parser
   • bash onnx_parser/use_tensorrt_8.x.sh
2. 配置 Makefile/CMakeLists.txt 中指向 TensorRT 8.x 的路径。
3. 执行 make yolo -j64

• 如果 PyTorch ≥ 1.7，且模型为 5.0+，则该框架支持此模型。
• 如果 PyTorch < 1.7 或 YOLOv5 为 2.0、3.0 或 4.0，则需要对 opset 进行小幅修改。
• 如果你想实现低版本 PyTorch 下的推理、动态批次大小以及其他高级设置，请查看我们的 博客（目前为中文），并通过微信扫描二维码加入我们。

1. 下载 YOLOv5

git clone git@github.com:ultralytics/yolov5.git

2. 修改代码以支持动态批次大小

# yolov5/models/yolo.py 中 forward 函数第 55 行
# bs, _, ny, nx = x[i].shape  # x(bs,255,20,20) 转为 x(bs,3,20,20,85)
# x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()
# 修改为：

bs, _, ny, nx = x[i].shape  # x(bs,255,20,20) 转为 x(bs,3,20,20,85)
bs = -1
ny = int(ny)
nx = int(nx)
x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()

# yolov5/models/yolo.py 第 70 行
# z.append(y.view(bs, -1, self.no))
# 修改为：
z.append(y.view(bs, self.na * ny * nx, self.no))

############# 对于 YOLOv5-6.0 #####################
# yolov5/models/yolo.py 第 65 行
# if self.grid[i].shape[2:4] != x[i].shape[2:4] or self.onnx_dynamic:
#    self.grid[i], self.anchor_grid[i] = self._make_grid(nx, ny, i)
# 修改为：
if self.grid[i].shape[2:4] != x[i].shape[2:4] or self.onnx_dynamic:
    self.grid[i], self.anchor_grid[i] = self._make_grid(nx, ny, i)

# 断开 PyTorch trace 的连接
anchor_grid = (self.anchors[i].clone() * self.stride[i]).view(1, -1, 1, 1, 2)

# yolov5/models/yolo.py 第 70 行
# y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i]  # wh
# 修改为：
y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * anchor_grid  # wh

# yolov5/models/yolo.py 第 73 行
# wh = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i]  # wh
# 修改为：
wh = (y[..., 2:4] * 2) ** 2 * anchor_grid  # wh
############# 对于 YOLOv5-6.0 #####################


# yolov5/export.py 第 52 行
# torch.onnx.export(dynamic_axes={'images': {0: 'batch', 2: 'height', 3: 'width'},  # 形状(1,3,640,640)
#                                'output': {0: 'batch', 1: 'anchors'}  # 形状(1,25200,85) 修改为
# 修改为：
torch.onnx.export(dynamic_axes={'images': {0: 'batch'},  # 形状(1,3,640,640)
                                'output': {0: 'batch'}  # 形状(1,25200,85) 

3. 导出为 ONNX 模型

cd yolov5
python export.py --weights=yolov5s.pt --dynamic --include=onnx --opset=11

4. 复制模型并执行

cp yolov5/yolov5s.onnx tensorRT_cpp/workspace/
cd tensorRT_cpp
make yolo -j32

# 来自 CDN

# 或者使用 wget 下载：https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt

wget https://cdn.githubjs.cf/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt
git clone git@github.com:WongKinYiu/yolov7.git

2. 修改代码以支持动态批次大小

# yolov7/models/yolo.py 中的第45行 forward 函数
# bs, _, ny, nx = x[i].shape  # x(bs,255,20,20) 转为 x(bs,3,20,20,85)
# x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()
# 修改为：

bs, _, ny, nx = map(int, x[i].shape)  # x(bs,255,20,20) 转为 x(bs,3,20,20,85)
bs = -1
x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()

# yolov7/models/yolo.py 中的第52行
# y = x[i].sigmoid()
# y[..., 0:2] = (y[..., 0:2] * 2. - 0.5 + self.grid[i]) * self.stride[i]  # xy
# y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i]  # wh
# z.append(y.view(bs, -1, self.no))
# 修改为：
y = x[i].sigmoid()
xy = (y[..., 0:2] * 2. - 0.5 + self.grid[i]) * self.stride[i]  # xy
wh = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i].view(1, -1, 1, 1, 2)  # wh
classif = y[..., 4:]
y = torch.cat([xy, wh, classif], dim=-1)
z.append(y.view(bs, self.na * ny * nx, self.no))

# yolov7/models/yolo.py 中的第57行
# return x 如果处于训练模式，否则返回 (torch.cat(z, 1), x)
# 修改为：
return x 如果处于训练模式，否则返回 torch.cat(z, 1)


# yolov7/models/export.py 中的第52行
# output_names=['classes', 'boxes'] 如果 y 为空，则为 ['output'],
# dynamic_axes={'images': {0: 'batch', 2: 'height', 3: 'width'},  // 尺寸(1,3,640,640)
#               'output': {0: 'batch', 2: 'y', 3: 'x'}} 如果 opt.dynamic 为真，则设置，否则为 None)
# 修改为：
output_names=['classes', 'boxes'] 如果 y 为空，则为 ['output'],
dynamic_axes={'images': {0: 'batch'},  // 尺寸(1,3,640,640)
              'output': {0: 'batch'}} 如果 opt.dynamic 为真，则设置，否则为 None)

3. 导出为 ONNX 模型

cd yolov7
python models/export.py --dynamic --grid --weight=yolov7.pt

4. 复制模型并执行

cp yolov7/yolov7.onnx tensorRT_cpp/workspace/
cd tensorRT_cpp
make yolo -j32

• 下载地址：https://github.com/Megvii-BaseDetection/YOLOX
• 如果不想自己导出 ONNX 文件，可以直接在 Megvii 的仓库中运行。

1. 下载 YoloX

git clone git@github.com:Megvii-BaseDetection/YOLOX.git
cd YOLOX

2. 修改代码 修改后的代码可以确保成功进行 int8 编译和推理，否则会抛出 Missing scale and zero-point for tensor (Unnamed Layer* 686) 错误。

# yolox/models/yolo_head.py 中的第206行 forward 函数。将注释掉的代码替换为未注释的代码
# self.hw = [x.shape[-2:] for x in outputs] 
self.hw = [list(map(int, x.shape[-2:])) for x in outputs]


# yolox/models/yolo_head.py 中的第208行 forward 函数。将注释掉的代码替换为未注释的代码
# [batch, n_anchors_all, 85]
# outputs = torch.cat(
#     [x.flatten(start_dim=2) for x in outputs], dim=2
# ).permute(0, 2, 1)
proc_view = lambda x: x.view(-1, int(x.size(1)), int(x.size(2) * x.size(3)))
outputs = torch.cat(
    [proc_view(x) for x in outputs], dim=2
).permute(0, 2, 1)


# yolox/models/yolo_head.py 中的第253行 decode_output 函数。将注释掉的代码替换为未注释的代码
#outputs[..., :2] = (outputs[..., :2] + grids) * strides
#outputs[..., 2:4] = torch.exp(outputs[..., 2:4]) * strides
#return outputs
xy = (outputs[..., :2] + grids) * strides
wh = torch.exp(outputs[..., 2:4]) * strides
return torch.cat((xy, wh, outputs[..., 4:]), dim=-1)

# tools/export_onnx.py 中的第77行
model.head.decode_in_inference = True

3. 导出为 ONNX

# 下载模型
wget https://github.com/Megvii-BaseDetection/YOLOX/releases/download/0.1.1rc0/yolox_m.pth

# 导出
export PYTHONPATH=$PYTHONPATH:.
python tools/export_onnx.py -c yolox_m.pth -f exps/default/yolox_m.py --output-name=yolox_m.onnx --dynamic --no-onnxsim

4. 执行命令

cp YOLOX/yolox_m.onnx tensorRT_cpp/workspace/
cd tensorRT_cpp
make yolo -j32

• 如果 PyTorch 版本 ≥ 1.7，且模型版本 ≥ 5.0，则框架本身即可支持该模型。
• 如果 PyTorch 版本 < 1.7 或是 YOLOv3 模型，则需要对 opset 进行小幅调整。
• 若希望在较低版本的 PyTorch 上实现推理，或使用动态批次大小等高级功能，请查看我们的博客（目前为中文），并通过微信扫描二维码加入我们。

1. 下载 YOLOv3

git clone git@github.com:ultralytics/yolov3.git

2. 修改代码以支持动态批次大小

# yolov3/models/yolo.py 中的第55行 forward 函数
# bs, _, ny, nx = x[i].shape  // x(bs,255,20,20) 转为 x(bs,3,20,20,85)
# x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()
# 修改为：

bs, _, ny, nx = map(int, x[i].shape)  // x(bs,255,20,20) 转为 x(bs,3,20,20,85)
bs = -1
x[i] = x[i].view(bs, self.na, self.no, ny, nx).permute(0, 1, 3, 4, 2).contiguous()


# yolov3/models/yolo.py 中的第70行
#  z.append(y.view(bs, -1, self.no))
# 修改为：
z.append(y.view(bs, self.na * ny * nx, self.no))

# yolov3/models/yolo.py 中的第62行
# 如果 self.grid[i].shape[2:4] 不等于 x[i].shape[2:4] 或者 self.onnx_dynamic 为真，
#    则更新 self.grid[i] 和 self.anchor_grid[i] 使用 _make_grid(nx, ny, i) 方法
# 修改为：
如果 self.grid[i].shape[2:4] 不等于 x[i].shape[2:4] 或者 self.onnx_dynamic 为真，
    则更新 self.grid[i] 和 self.anchor_grid[i] 使用 _make_grid(nx, ny, i) 方法
anchor_grid = (self.anchors[i].clone() * self.stride[i]).view(1, -1, 1, 1, 2)

# yolov3/models/yolo.py 中的第70行
# y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i]  // wh
# 修改为：
y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * anchor_grid  // wh

# yolov3/models/yolo.py 中的第73行
# wh = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i]  // wh
# 修改为：
wh = (y[..., 2:4] * 2) ** 2 * anchor_grid  // wh


# yolov3/export.py 中的第52行
# torch.onnx.export(dynamic_axes={'images': {0: 'batch', 2: 'height', 3: 'width'},  // 形状(1,3,640,640)
#                                'output': {0: 'batch', 1: 'anchors'}  // 形状(1,25200,85) 
# 修改为：
torch.onnx.export(dynamic_axes={'images': {0: 'batch'},  // 形状(1,3,640,640)
                                'output': {0: 'batch'}  // 形状(1,25200,85) 

3. 导出为 ONNX 模型

cd yolov3
python export.py --weights=yolov3.pt --dynamic --include=onnx --opset=11

4. 复制模型并执行

cp yolov3/yolov3.onnx tensorRT_cpp/workspace/
cd tensorRT_cpp

# 修改 src/application/app_yolo.cpp: main

# 测试(Yolo::Type::V3, TRT::Mode::FP32, "yolov3");

make yolo -j32

• 参考链接：https://github.com/shouxieai/unet-pytorch

make dunet -j32

• https://github.com/biubug6/Pytorch_Retinaface

1. 下载Pytorch_Retinaface仓库

git clone git@github.com:biubug6/Pytorch_Retinaface.git
cd Pytorch_Retinaface

2. 从https://github.com/biubug6/Pytorch_Retinaface#training中的README.md训练部分下载模型，然后解压到/weights目录。这里我们使用mobilenet0.25_Final.pth。

3. 修改代码

# models/retinaface.py第24行
# return out.view(out.shape[0], -1, 2) 修改为
return out.view(-1, int(out.size(1) * out.size(2) * 2), 2)

# models/retinaface.py第35行
# return out.view(out.shape[0], -1, 4) 修改为
return out.view(-1, int(out.size(1) * out.size(2) * 2), 4)

# models/retinaface.py第46行
# return out.view(out.shape[0], -1, 10) 修改为
return out.view(-1, int(out.size(1) * out.size(2) * 2), 10)

# 下面的修改确保resize节点的输出基于缩放比例而非固定形状，从而实现动态批处理。
# models/net.py第89行
# up3 = F.interpolate(output3, size=[output2.size(2), output2.size(3)], mode="nearest") 修改为
up3 = F.interpolate(output3, scale_factor=2, mode="nearest")

# models/net.py第93行
# up2 = F.interpolate(output2, size=[output1.size(2), output1.size(3)], mode="nearest") 修改为
up2 = F.interpolate(output2, scale_factor=2, mode="nearest")

# 下面的代码移除了softmax（有时会出现问题），同时将输出拼接起来以简化解码过程。
# models/retinaface.py第123行
# if self.phase == 'train':
#     output = (bbox_regressions, classifications, ldm_regressions)
# else:
#     output = (bbox_regressions, F.softmax(classifications, dim=-1), ldm_regressions)
# return output
# 上述内容修改为：
output = (bbox_regressions, classifications, ldm_regressions)
return torch.cat(output, dim=-1)

# 设置'opset_version=11'以确保导出成功。
# torch_out = torch.onnx._export(net, inputs, output_onnx, export_params=True, verbose=False,
#     input_names=input_names, output_names=output_names)
# 修改为：
torch_out = torch.onnx._export(net, inputs, output_onnx, export_params=True, verbose=False, opset_version=11,
    input_names=input_names, output_names=output_names)

4. 导出为ONNX格式

python convert_to_onnx.py

5. 执行

cp FaceDetector.onnx ../tensorRT_cpp/workspace/mb_retinaface.onnx
cd ../tensorRT_cpp
make retinaface -j64

• https://github.com/dlunion/DBFace

make dbface -j64

• https://github.com/deepinsight/insightface/tree/master/detection/scrfd
• 关于导出为ONNX格式的技术细节即将发布。在正式发布之前，欢迎加入我们进行讨论。

• https://github.com/deepinsight/insightface/tree/master/recognition/arcface_torch

auto arcface = Arcface::create_infer("arcface_iresnet50.fp32.trtmodel", 0);
auto feature = arcface->commit(make_tuple(face, landmarks)).get();
cout << feature << endl;  // 1x512

• 在人脸识别示例中，workspace/face/library是已注册的人脸集合。
• workspace/face/recognize是要识别的人脸集合。
• 结果保存在workspace/face/result和workspace/face/library_draw中。

请参阅教程/2.0中的详细说明。

• https://github.com/649453932/Bert-Chinese-Text-Classification-Pytorch
• make bert -j6

• 仅需一行代码即可导出 ONNX 和 TRT 模型，并将其保存以供后续使用。

import pytrt

model = models.resnet18(True).eval()
pytrt.from_torch(
    model, 
    dummy_input, 
    max_batch_size=16, 
    onnx_save_file="test.onnx", 
    engine_save_file="engine.trtmodel"
)

• YOLOX TensorRT 推理

import pytrt

yolo   = tp.Yolo(engine_file, type=tp.YoloType.X)   # engine_file 是 TRT 模型文件
image  = cv2.imread("inference/car.jpg")
bboxes = yolo.commit(image).get()

• 从 PyTorch 到 TensorRT 的无缝推理

import pytrt

model     = models.resnet18(True).eval().to(device) # PyTorch 模型
trt_model = tp.from_torch(model, input)
trt_out   = trt_model(input)

// 在 GPU 0 上创建推理引擎
auto engine = Yolo::create_infer("yolox_m.fp32.trtmodel"， Yolo::Type::X, 0);

// 加载图像
auto image = cv::imread("1.jpg");

// 进行推理并获取结果
auto box = engine->commit(image).get();

TRT::compile(
  TRT::Mode::FP32,   // 以 FP32 编译模型
  3,                          // 最大批量大小
  "plugin.onnx",              // ONNX 文件
  "plugin.fp32.trtmodel",     // 保存路径
  {}                         // 需要时重新定义输入形状
);

• 对于 FP32 编译，你只需提供一个允许重新定义输入形状的 ONNX 文件。

• INT8 推理在精度上略逊于 FP32（约下降 5%），但速度却快得惊人。在该框架中，我们提供了 INT8 推理功能。

// 定义 INT8 校准函数，用于读取数据并处理为张量。
auto int8process = [](int current, int count, vector<string>& images, shared_ptr<TRT::Tensor>& tensor){
    for(int i = 0; i < images.size(); ++i){
    // INT8 编译需要校准。我们读取图像数据并设置归一化矩阵，然后将数据转换为张量。
        auto image = cv::imread(images[i]);
        cv::resize(image, image, cv::Size(640, 640));
        float mean[] = {0, 0, 0};
        float std[]  = {1, 1, 1};
        tensor->set_norm_mat(i, image, mean, std);
    }
};


// 指定 TRT::Mode 为 INT8
auto model_file = "yolov5m.int8.trtmodel";
TRT::compile(
  TRT::Mode::INT8,            // INT8
  3,                          // 最大批量大小
  "yolov5m.onnx",             // ONNX
  model_file,                 // 保存文件名
  {},                         // 重新定义输入形状
  int8process,                // 校准回调函数
  ".",                        // 用于校准的图像数据所在目录
  ""                          // 校准数据保存目录（即加载校准数据的地方）
);

• 我们通过整合一个 int8process 函数，避免了 TensorRT 官方实现中可能出现的诸多问题。

• 我们引入了 Tensor 类，以便更轻松地进行推理和主机与设备之间的数据传输，从而让用户无需关注底层细节。

• Engine 类是另一个便利工具。

// 加载模型并获取共享指针。如果加载失败，则返回 nullptr。
auto engine = TRT::load_infer("yolov5m.fp32.trtmodel");

// 打印模型信息
engine->print();

// 加载图像
auto image = imread("demo.jpg");

// 获取模型的输入和输出节点，可以通过名称或索引访问
auto input = engine->input(0);   // 或者 auto input = engine->input("images");
auto output = engine->output(0); // 或者 auto output = engine->output("output");

// 调用 set_norm_mat() 将图像放入输入张量中
float mean[] = {0, 0, 0};
float std[]  = {1, 1, 1};
input->set_norm_mat(i, image, mean, std);

// 进行推理。这里 sync(true) 或 async(false) 是可选的
engine->forward(); // engine->forward(true 或 false)

// 获取输出指针，用于访问输出结果
float* output_ptr = output->cpu<float>();

• 你只需定义核函数和推理过程即可。代码的细节（例如插件的序列化、反序列化和注入等）都由框架自动处理。
• 很容易实现新的 FP32 和 FP16 插件。详情请参阅 HSwish.cu。

template<>
__global__ void HSwishKernel(float* input, float* output, int edge) {

    KernelPositionBlock;
    float x = input[position];
    float a = x + 3;
    a = a < 0 ? 0 : (a >= 6 ? 6 : a);
    output[position] = x * a / 6;
}

int HSwish::enqueue(const std::vector<GTensor>& inputs, std::vector<GTensor>& outputs, const std::vector<GTensor>& weights, void* workspace, cudaStream_t stream) {

    int count = inputs[0].count();
    auto grid = CUDATools::grid_dims(count);
    auto block = CUDATools::block_dims(count);
    HSwishKernel <<<grid, block, 0, stream >>> (inputs[0].ptr<float>(), outputs[0].ptr<float>(), count);
    return 0;
}


RegisterPlugin(HSwish);