PaddlePaddle
diff --git a/‎paddle/fluid/pir/transforms/tensorrt/trt_op_marker_pass.cc
Copy file name to clipboard
+104-2Lines changed: 104 additions & 2 deletions b/‎paddle/fluid/pir/transforms/tensorrt/trt_op_marker_pass.cc
Copy file name to clipboard
+104-2Lines changed: 104 additions & 2 deletions
diff --git a/‎python/paddle/tensorrt/converter.py
Copy file name to clipboard
+15-1Lines changed: 15 additions & 1 deletion b/‎python/paddle/tensorrt/converter.py
Copy file name to clipboard
+15-1Lines changed: 15 additions & 1 deletion
diff --git a/‎python/paddle/tensorrt/impls/activation.py
Copy file name to clipboard
+30Lines changed: 30 additions & 0 deletions b/‎python/paddle/tensorrt/impls/activation.py
Copy file name to clipboard
+30Lines changed: 30 additions & 0 deletions
diff --git a/‎python/paddle/tensorrt/impls/ops.py
Copy file name to clipboard
+24Lines changed: 24 additions & 0 deletions b/‎python/paddle/tensorrt/impls/ops.py
Copy file name to clipboard
+24Lines changed: 24 additions & 0 deletions
@@ -22,6 +22,8 @@
 #include "paddle/fluid/pir/dialect/operator/ir/pd_op.h"
 #include "paddle/fluid/pir/utils/general_functions.h"
 
+#include "paddle/fluid/pir/dialect/operator/utils/utils.h"
+#include "paddle/fluid/platform/tensorrt/helper.h"
 #include "paddle/pir/include/core/builtin_attribute.h"
 #include "paddle/pir/include/core/builtin_op.h"
 #include "paddle/pir/include/pass/pass.h"
@@ -70,6 +72,8 @@ DEFINE_GENERAL_PATTERN(DepthwiseConv2d, paddle::dialect::DepthwiseConv2dOp)
 DEFINE_GENERAL_PATTERN(Shape, paddle::dialect::ShapeOp)
 DEFINE_GENERAL_PATTERN(Expand, paddle::dialect::ExpandOp)
 DEFINE_GENERAL_PATTERN(Sigmoid, paddle::dialect::SigmoidOp)
+DEFINE_GENERAL_PATTERN(Hardsigmoid, paddle::dialect::HardsigmoidOp)
+DEFINE_GENERAL_PATTERN(Hardswish, paddle::dialect::HardswishOp)
 
 #undef DEFINE_GENERAL_PATTERN
 
@@ -1088,6 +1092,101 @@ class RemainderOpPattern
     return true;
   }
 };
+
+class MulticlassNms3OpPattern
+    : public pir::OpRewritePattern<paddle::dialect::MulticlassNms3Op> {
+ public:
+  using pir::OpRewritePattern<
+      paddle::dialect::MulticlassNms3Op>::OpRewritePattern;
+  bool MatchAndRewrite(paddle::dialect::MulticlassNms3Op op,
+                       pir::PatternRewriter &rewriter) const override {
+    if (op->HasAttribute(kCanRunTrtAttr) &&
+        op.attribute<pir::BoolAttribute>(kCanRunTrtAttr).data()) {
+      return false;
+    }
+    auto rois_num = op.operand_source(2);
+    if (rois_num.impl() != nullptr) {
+      return false;
+    }
+    for (auto operand : op->operands()) {
+      auto operand_source = operand.source();
+      if (operand_source.impl() == nullptr) {
+        continue;
+      }
+      auto shape = operand_source.type()
+                       .dyn_cast<paddle::dialect::DenseTensorType>()
+                       .dims();
+      if (shape.size() != 3) {
+        VLOG(3) << "multiclass_nms op dims != 3 not supported in tensorrt, "
+                   "but got dims "
+                << shape.size() << ", so jump it.";
+        return false;
+      }
+    }
+    bool has_attrs =
+        (op->HasAttribute("background_label") &&
+         op->HasAttribute("score_threshold") && op->HasAttribute("nms_top_k") &&
+         op->HasAttribute("keep_top_k") && op->HasAttribute("normalized"));
+    if (has_attrs == false) return false;
+
+    // TODO(wangxinxin08): tricky solution because the outputs of batchedNMS
+    // plugin are not constient with those of multiclass_nms3
+    if (op->HasAttribute("nms_eta") == false) return false;
+    auto nms_eta = op.attribute<pir::FloatAttribute>("nms_eta").data();
+    if (nms_eta <= 1.0) return false;
+
+    auto nms_top_k = op.attribute<pir::Int32Attribute>("nms_top_k").data();
+    if (nms_top_k < 0) return false;
+
+    auto keep_top_k = op.attribute<pir::Int32Attribute>("keep_top_k").data();
+    if (keep_top_k < 0) return false;
+
+    auto registry = paddle::platform::GetPluginRegistry();
+
+    if (registry == nullptr) return false;
+    op->set_attribute(kCanRunTrtAttr, rewriter.bool_attr(true));
+    return true;
+  }
+};
+
+class ArgmaxOpPattern
+    : public pir::OpRewritePattern<paddle::dialect::ArgmaxOp> {
+ public:
+  using pir::OpRewritePattern<paddle::dialect::ArgmaxOp>::OpRewritePattern;
+  bool MatchAndRewrite(paddle::dialect::ArgmaxOp op,
+                       pir::PatternRewriter &rewriter) const override {
+    if (op->HasAttribute(kCanRunTrtAttr) &&
+        op.attribute<pir::BoolAttribute>(kCanRunTrtAttr).data()) {
+      return false;
+    }
+    if (!op.axis().defining_op()->isa<paddle::dialect::FullOp>()) {
+      VLOG(3) << "Skip to convert into TRT while found axis is not a constant "
+                 "data in arg_max.";
+      return false;
+    }
+    auto x = op.x();
+    auto x_tensor_type = x.type().dyn_cast<paddle::dialect::DenseTensorType>();
+    auto data_type = paddle::dialect::TransToPhiDataType(x_tensor_type.dtype());
+    if (!(data_type == phi::DataType::FLOAT32 ||
+          data_type == phi::DataType::FLOAT16 ||
+          data_type == phi::DataType::FLOAT64)) {
+      return false;
+    }
+    int axis = static_cast<int>(op.axis()
+                                    .defining_op()
+                                    ->attribute<pir::DoubleAttribute>("value")
+                                    .data());
+
+    bool flatten = op.attribute<pir::BoolAttribute>("flatten").data();
+    phi::DataType dtype =
+        op.attribute<paddle::dialect::DataTypeAttribute>("dtype").data();
+    if (axis == 0 || flatten ||
+        (dtype != phi::DataType::INT32 && dtype != phi::DataType::INT64))
+      return false;
+    op->set_attribute(kCanRunTrtAttr, rewriter.bool_attr(true));
+    return true;
+  }
+};
 class MaxOpPattern : public pir::OpRewritePattern<paddle::dialect::MaxOp> {
  public:
   using pir::OpRewritePattern<paddle::dialect::MaxOp>::OpRewritePattern;
@@ -1114,6 +1213,7 @@ class MaxOpPattern : public pir::OpRewritePattern<paddle::dialect::MaxOp> {
     return true;
   }
 };
+
 class TrtOpMarkerPass : public pir::PatternRewritePass {
  public:
   TrtOpMarkerPass() : pir::PatternRewritePass("trt_op_marker_pass", 2) {}
@@ -1145,6 +1245,8 @@ class TrtOpMarkerPass : public pir::PatternRewritePass {
     ADD_PATTERN(Shape)
     ADD_PATTERN(Expand)
     ADD_PATTERN(Sigmoid)
+    ADD_PATTERN(Hardsigmoid)
+    ADD_PATTERN(Hardswish)
 #if IS_TRT_VERSION_GE(8600)
     ADD_PATTERN(Layer_norm)
 #endif
@@ -1179,15 +1281,15 @@ class TrtOpMarkerPass : public pir::PatternRewritePass {
     ps.Add(std::make_unique<MaximumOpPattern>(context));
     ps.Add(std::make_unique<FloorDivideOpPattern>(context));
     ps.Add(std::make_unique<RemainderOpPattern>(context));
+    ps.Add(std::make_unique<MulticlassNms3OpPattern>(context));
+    ps.Add(std::make_unique<ArgmaxOpPattern>(context));
     ps.Add(std::make_unique<MaxOpPattern>(context));
     return ps;
   }
 };
-
 }  // namespace
 
 namespace pir {
-
 std::unique_ptr<Pass> CreateTrtOpMarkerPass() {
   return std::make_unique<TrtOpMarkerPass>();
 }
 
@@ -12,12 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import ctypes
 import hashlib
 import logging
 
 import numpy as np
 import tensorrt as trt
 
+# init tensorrt plugin
+trt_plugin_lib = ctypes.CDLL('libnvinfer_plugin.so')
+trt_plugin_lib.initLibNvInferPlugins(None, "")
+
 import paddle
 from paddle import pir
 from paddle.base.core import get_value_shape_range_info
@@ -30,6 +35,8 @@
 from .impls.manipulation import *  # noqa: F403
 from .impls.math import *  # noqa: F403
 from .impls.norm import *  # noqa: F403
+from .impls.ops import *  # noqa: F403
+from .impls.others import *  # noqa: F403
 from .impls.pooling import *  # noqa: F403
 from .impls.search import *  # noqa: F403
 from .register import converter_registry
@@ -95,7 +102,11 @@ def __is_output_value(value):
                     graph_output_values.append(result)
             for operand in op.operands():
                 source = operand.source()
-                all_values[source.id] = source
+                if not source.initialized():
+                    _logger.warning(f"Skipping uninitialized source: {source}")
+                    continue
+                else:
+                    all_values[source.id] = source
 
         # Input values are those that are in all_values but not in output_values
         input_values = [
@@ -186,6 +197,9 @@ def convert_subgraph_to_trt(self, program, group_op):
             operands = []
             for operand in op.operands():
                 source = operand.source()
+                if not source.initialized():
+                    _logger.warning(f"Skipping uninitialized source: {source}")
+                    continue
                 define_op_name = source.get_defining_op().name()
                 if define_op_name == "builtin.combine":
                     for combined_operand in source.get_defining_op().operands():
 
@@ -73,3 +73,33 @@ def gelu_converter(network, paddle_op, inputs):
 
     layer = network.add_plugin_v2([input_val], plugin)
     return layer.get_output(0)
+
+
+@converter_registry.register("pd_op.hardsigmoid", trt_version="8.x")
+def hardsigmoid_converter(network, paddle_op, inputs):
+    x = inputs[0]
+    slope = paddle_op.attrs()["slope"]
+    offset = paddle_op.attrs()["offset"]
+    hardsigmoid_layer = network.add_activation(
+        x, trt.ActivationType.HARD_SIGMOID
+    )
+    hardsigmoid_layer.alpha = slope
+    hardsigmoid_layer.beta = offset
+    return hardsigmoid_layer.get_output(0)
+
+
+@converter_registry.register("pd_op.hardswish", trt_version="8.x")
+def hardswish_converter(network, paddle_op, inputs):
+    x = inputs[0]
+    threshold = 6.0
+    scale = 6.0
+    offset = 3.0
+    hardsigmoid_layer = network.add_activation(
+        x, trt.ActivationType.HARD_SIGMOID
+    )
+    hardsigmoid_layer.alpha = 1.0 / scale
+    hardsigmoid_layer.beta = offset / scale
+    hardswish_layer = network.add_elementwise(
+        x, hardsigmoid_layer.get_output(0), trt.ElementWiseOperation.PROD
+    )
+    return hardswish_layer.get_output(0)
@@ -0,0 +1,24 @@
+# Copyright (c) 2024 PaddlePaddle Authors. All Rights Reserved
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import tensorrt as trt
+
+from paddle.tensorrt.register import converter_registry
+
+
+@converter_registry.register("pd_op.sigmoid", trt_version="8.x")
+def sigmoid_converter(network, paddle_op, inputs):
+    sigmoid_layer = network.add_activation(
+        inputs[0], trt.ActivationType.SIGMOID
+    )
+    return sigmoid_layer.get_output(0)