fix error for ocr model

lite/core/optimizer/mir/xpu_memory_optimize_pass.cc

@@ -54,6 +54,7 @@ void XPUMemoryOptimizePass::CollectLifeCycleByDevice(SSAGraph* graph) {
       "scale",
       "__xpu__resnet50",
       "softmax",
+      "select_input",
   };
 
   auto insert_invalid_op_nodes_for_specific_target =

lite/kernels/host/cast_compute.cc

@@ -136,6 +136,11 @@ void CastCompute::Run() {
     const int32_t* x_data_end = x_data_begin + param.X->numel();
     bool* out_data = param.Out->mutable_data<bool>();
     std::transform(x_data_begin, x_data_end, out_data, TransOp<int32_t, bool>);
+  } else if (param.in_dtype == 3 && param.out_dtype == 0) {  // INT64 -> bool
+    const int64_t* x_data_begin = param.X->data<int64_t>();
+    const int64_t* x_data_end = x_data_begin + param.X->numel();
+    bool* out_data = param.Out->mutable_data<bool>();
+    std::transform(x_data_begin, x_data_end, out_data, TransOp<int64_t, bool>);
   } else if (param.in_dtype == 2 && param.out_dtype == 2) {  // INT32 -> INT32
     const int32_t* x_data_begin = param.X->data<int32_t>();
     const int32_t* x_data_end = x_data_begin + param.X->numel();

lite/kernels/xpu/CMakeLists.txt

@@ -64,6 +64,7 @@ add_kernel(where_compute_xpu XPU extra SRCS where_compute.cc)
 add_kernel(gather_nd_compute_xpu XPU extra SRCS gather_nd_compute.cc)
 add_kernel(meshgrid_compute_xpu XPU basic SRCS meshgrid_compute.cc)
 add_kernel(fetch_compute_xpu XPU basic SRCS fetch_compute.cc)
+add_kernel(unbind_compute_xpu XPU basic SRCS unbind_compute.cc)
 
 # extra
 add_kernel(lookup_table_compute_xpu XPU extra SRCS lookup_table_compute.cc)

lite/kernels/xpu/activation_compute.cc

@@ -75,10 +75,10 @@ void SigmoidCompute<T, PType>::Run() {
   auto& param = this->template Param<param_t>();
   auto& ctx = this->ctx_->template As<XPUContext>();
 
-  int r = xdnn::fast_sigmoid(ctx.GetRawContext(),
-                             param.X->template data<T>(),
-                             param.Out->template mutable_data<T>(TARGET(kXPU)),
-                             param.X->numel());
+  int r = xdnn::sigmoid(ctx.GetRawContext(),
+                        param.X->template data<T>(),
+                        param.Out->template mutable_data<T>(TARGET(kXPU)),
+                        param.X->numel());
   CHECK_EQ(r, 0);
 }
 

lite/kernels/xpu/compare_compute.cc

@@ -82,6 +82,14 @@ void CompareCompute<PType, T, Functor>::Run() {
   const auto* y = param.Y->template data<T>();
 
   auto& ctx = this->ctx_->template As<XPUContext>();
+
+  if (x_dims.size() == 0) {
+    x_dims.ConstructFrom({1});
+  }
+  if (y_dims.size() == 0) {
+    y_dims.ConstructFrom({1});
+  }
+
   Functor comp_func;
   std::vector<int> xshape;
   std::vector<int> yshape;

lite/kernels/xpu/linspace_compute.cc

@@ -21,6 +21,22 @@ namespace lite {
 namespace kernels {
 namespace xpu {
 
+template <typename T>
+T GetValueOfExpectedType(const lite::Tensor* x) {
+  switch (x->precision()) {
+    case PRECISION(kFloat):
+      return static_cast<T>(x->template data<float>()[0]);
+    case PRECISION(kInt32):
+      return static_cast<T>(x->template data<int32_t>()[0]);
+    case PRECISION(kInt64):
+      return static_cast<T>(x->template data<int64_t>()[0]);
+    default:
+      LOG(FATAL) << "data type is not supported: "
+                 << lite_api::PrecisionToStr(x->precision());
+      return static_cast<T>(0);
+  }
+}
+
 template <typename T, PrecisionType PType>
 void LinspaceCompute<T, PType>::Run() {
   auto& param = this->template Param<operators::LinspaceParam>();
@@ -31,20 +47,31 @@ void LinspaceCompute<T, PType>::Run() {
   auto* out_tensor = param.Out;
   int64_t num = static_cast<int64_t>(num_tensor->template data<int>()[0]);
   int r = -1;
+
+  T start_val = GetValueOfExpectedType<T>(start_tensor);
+  T stop_val = GetValueOfExpectedType<T>(stop_tensor);
   switch (param.Out->precision()) {
     case PRECISION(kFloat):
       r = xdnn::linspace<T>(ctx.GetRawContext(),
                             out_tensor->template mutable_data<T>(TARGET(kXPU)),
-                            static_cast<T>(start_tensor->template data<T>()[0]),
-                            static_cast<T>(stop_tensor->template data<T>()[0]),
+                            start_val,
+                            stop_val,
                             num);
       CHECK_EQ(r, 0);
       break;
     case PRECISION(kInt32):
       r = xdnn::linspace<T>(ctx.GetRawContext(),
                             out_tensor->template mutable_data<T>(TARGET(kXPU)),
-                            static_cast<T>(start_tensor->template data<T>()[0]),
-                            static_cast<T>(stop_tensor->template data<T>()[0]),
+                            start_val,
+                            stop_val,
+                            num);
+      CHECK_EQ(r, 0);
+      break;
+    case PRECISION(kInt64):
+      r = xdnn::linspace<T>(ctx.GetRawContext(),
+                            out_tensor->template mutable_data<T>(TARGET(kXPU)),
+                            start_val,
+                            stop_val,
                             num);
       CHECK_EQ(r, 0);
       break;

lite/kernels/xpu/scale_compute.cc

@@ -21,8 +21,8 @@ namespace lite {
 namespace kernels {
 namespace xpu {
 
-template <typename T>
-void ScaleCompute<T>::Run() {
+template <typename T, PrecisionType PType>
+void ScaleCompute<T, PType>::Run() {
   auto& param = this->template Param<param_t>();
   auto& ctx = this->ctx_->template As<XPUContext>();
 
@@ -52,32 +52,30 @@ void ScaleCompute<T>::Run() {
 }  // namespace lite
 }  // namespace paddle
 
-REGISTER_LITE_KERNEL(scale,
-                     kXPU,
-                     kFloat,
-                     kNCHW,
-                     paddle::lite::kernels::xpu::ScaleCompute<float>,
-                     def)
+using XPUScale_FP32 =
+    paddle::lite::kernels::xpu::ScaleCompute<float, PRECISION(kFloat)>;
+REGISTER_LITE_KERNEL(scale, kXPU, kFloat, kNCHW, XPUScale_FP32, def)
     .BindInput("X", {LiteType::GetTensorTy(TARGET(kXPU))})
     .BindOutput("Out", {LiteType::GetTensorTy(TARGET(kXPU))})
     .Finalize();
 
-REGISTER_LITE_KERNEL(scale,
-                     kXPU,
-                     kFloat,
-                     kNCHW,
-                     paddle::lite::kernels::xpu::ScaleCompute<int>,
-                     int32)
+using XPUScale_FP16 =
+    paddle::lite::kernels::xpu::ScaleCompute<float16, PRECISION(kFP16)>;
+REGISTER_LITE_KERNEL(scale, kXPU, kFP16, kNCHW, XPUScale_FP16, fp16)
+    .BindInput("X", {LiteType::GetTensorTy(TARGET(kXPU), PRECISION(kFP16))})
+    .BindOutput("Out", {LiteType::GetTensorTy(TARGET(kXPU), PRECISION(kFP16))})
+    .Finalize();
+
+using XPUScale_Int32 =
+    paddle::lite::kernels::xpu::ScaleCompute<int, PRECISION(kFloat)>;
+REGISTER_LITE_KERNEL(scale, kXPU, kFloat, kNCHW, XPUScale_Int32, int32)
     .BindInput("X", {LiteType::GetTensorTy(TARGET(kXPU), PRECISION(kInt32))})
     .BindOutput("Out", {LiteType::GetTensorTy(TARGET(kXPU), PRECISION(kInt32))})
     .Finalize();
 
-REGISTER_LITE_KERNEL(scale,
-                     kXPU,
-                     kFloat,
-                     kNCHW,
-                     paddle::lite::kernels::xpu::ScaleCompute<int64_t>,
-                     int64)
+using XPUScale_Int64 =
+    paddle::lite::kernels::xpu::ScaleCompute<int64_t, PRECISION(kFloat)>;
+REGISTER_LITE_KERNEL(scale, kXPU, kFloat, kNCHW, XPUScale_Int64, int64)
     .BindInput("X", {LiteType::GetTensorTy(TARGET(kXPU), PRECISION(kInt64))})
     .BindOutput("Out", {LiteType::GetTensorTy(TARGET(kXPU), PRECISION(kInt64))})
     .Finalize();

lite/kernels/xpu/scale_compute.h

@@ -21,8 +21,8 @@ namespace lite {
 namespace kernels {
 namespace xpu {
 
-template <typename T>
-class ScaleCompute : public KernelLite<TARGET(kXPU), PRECISION(kFloat)> {
+template <typename T, PrecisionType PType>
+class ScaleCompute : public KernelLite<TARGET(kXPU), PType> {
  public:
   using param_t = operators::ScaleParam;
 

lite/kernels/xpu/set_value_compute.cc

@@ -82,8 +82,8 @@ void SetValueCompute::SetValue(const std::vector<int64_t>& starts,
         __ends__,                                                      \
         __steps__,                                                     \
         param.axes,                                                    \
-        {},                                                            \
-        {});                                                           \
+        param.decrease_axes,                                           \
+        param.none_axes);                                              \
     CHECK_EQ(r, 0);                                                    \
     return;                                                            \
   }

lite/kernels/xpu/unbind_compute.cc

@@ -0,0 +1,61 @@
+// Copyright (c) 2023 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
+//
+//     http://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.
+
+#include "lite/kernels/xpu/unbind_compute.h"
+#include <vector>
+#include "lite/backends/xpu/xpu_header_sitter.h"
+#include "lite/core/op_registry.h"
+
+namespace paddle {
+namespace lite {
+namespace kernels {
+namespace xpu {
+
+template <typename T, PrecisionType PType>
+void UnbindCompute<T, PType>::Run() {
+  auto& param = this->template Param<param_t>();
+  auto& ctx = this->ctx_->template As<XPUContext>();
+  auto x = param.x;
+  auto& axis = param.axis;
+
+  auto output = param.output;
+
+  std::vector<T*> y_ptrs;
+  for (size_t j = 0; j < output.size(); ++j) {
+    y_ptrs.emplace_back(output[j]->template mutable_data<T>(TARGET(kXPU)));
+  }
+  auto x_shape = x->dims().Vectorize();
+  int r = xdnn::unbind(
+      ctx.GetRawContext(), x->template data<T>(), y_ptrs, x_shape, axis);
+  CHECK_EQ(r, 0);
+}
+
+}  // namespace xpu
+}  // namespace kernels
+}  // namespace lite
+}  // namespace paddle
+
+using unbind_fp32 =
+    paddle::lite::kernels::xpu::UnbindCompute<float, PRECISION(kFloat)>;
+REGISTER_LITE_KERNEL(unbind, kXPU, kFloat, kNCHW, unbind_fp32, def)
+    .BindInput("X", {LiteType::GetTensorTy(TARGET(kXPU), PRECISION(kFloat))})
+    .BindOutput("Out", {LiteType::GetTensorTy(TARGET(kXPU), PRECISION(kFloat))})
+    .Finalize();
+
+using unbind_int64 =
+    paddle::lite::kernels::xpu::UnbindCompute<int64_t, PRECISION(kFloat)>;
+REGISTER_LITE_KERNEL(unbind, kXPU, kFloat, kNCHW, unbind_int64, int64)
+    .BindInput("X", {LiteType::GetTensorTy(TARGET(kXPU), PRECISION(kInt64))})
+    .BindOutput("Out", {LiteType::GetTensorTy(TARGET(kXPU), PRECISION(kInt64))})
+    .Finalize();

lite/kernels/xpu/unbind_compute.h

@@ -0,0 +1,37 @@
+// Copyright (c) 2023 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
+//
+//     http://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.
+
+#pragma once
+
+#include "lite/core/kernel.h"
+
+namespace paddle {
+namespace lite {
+namespace kernels {
+namespace xpu {
+
+template <typename T, PrecisionType PType>
+class UnbindCompute : public KernelLite<TARGET(kXPU), PType> {
+ public:
+  using param_t = operators::UnbindParam;
+
+  virtual void Run();
+
+  virtual ~UnbindCompute() = default;
+};
+
+}  // namespace xpu
+}  // namespace kernels
+}  // namespace lite
+}  // namespace paddle

lite/operators/compare_op.cc

@@ -35,7 +35,7 @@ static void GetBroadcastDimsArrays(const DDim &x_dims,
   };
 
   CHECK_GE(axis, 0);
-  CHECK_LT(axis, max_dim);
+  CHECK_LE(axis, max_dim);
   if (x_dims.size() > y_dims.size()) {
     std::fill(y_dims_array, y_dims_array + axis, 1);
     if (axis + y_dims.size() < max_dim) {