mindspore 2.7.0__cp311-none-any.whl → 2.7.1__cp311-none-any.whl

mindspore/include/mindspore/ops/kernel/cpu/native/fill_cpu_kernel.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright 2022 Huawei Technologies Co., Ltd
+ *
+ * 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.
+ */
+
+#ifndef MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FILL_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FILL_CPU_KERNEL_H_
+
+#include <vector>
+#include <memory>
+#include <utility>
+#include <map>
+#include "kernel/cpu/cpu_kernel.h"
+#include "include/runtime/hardware_abstract/kernel_base/ms_factory.h"
+
+namespace mindspore {
+namespace kernel {
+namespace fill_cpu {
+class FillCpuKernelMod : public NativeCpuKernelMod, public MatchKernelHelper<FillCpuKernelMod> {
+ public:
+  FillCpuKernelMod() = default;
+  ~FillCpuKernelMod() override = default;
+
+  bool Init(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  int Resize(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  bool Launch(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &workspace,
+              const std::vector<KernelTensor *> &outputs) override {
+    return kernel_func_(this, inputs, workspace, outputs);
+  }
+
+  const std::vector<std::pair<KernelAttr, KernelRunFunc>> &GetFuncList() const override;
+  std::vector<size_t> GetLaunchIgnoredInputAddressIdx() const override { return {kShapeIndex_}; }
+
+ protected:
+  std::vector<KernelAttr> GetOpSupport() override { return OpSupport(); }
+
+ private:
+  template <typename T>
+  bool LaunchKernel(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &,
+                    const std::vector<KernelTensor *> &outputs);
+
+  template <typename T>
+  void CalculateDims(const KernelTensor *input, std::vector<int64_t> *dims) const;
+
+ private:
+  TypeId output_dtype_{kTypeUnknown};
+  TypeId input0_dtype_{kTypeUnknown};
+  TypeId x_type_id_;
+  static constexpr size_t kShapeIndex_{0};
+};
+}  // namespace fill_cpu
+}  // namespace kernel
+}  // namespace mindspore
+#endif  // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FILL_CPU_KERNEL_H_

mindspore/include/mindspore/ops/kernel/cpu/native/fill_diagonal_cpu_kernel.h

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2022 Huawei Technologies Co., Ltd
+ *
+ * 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.
+ */
+
+#ifndef MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FILL_DIAGONAL_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FILL_DIAGONAL_CPU_KERNEL_H_
+
+#include <vector>
+#include <map>
+#include "kernel/cpu/cpu_kernel.h"
+#include "include/runtime/hardware_abstract/kernel_base/ms_factory.h"
+
+namespace mindspore {
+namespace kernel {
+namespace fill_diagonal_cpu {
+class FillDiagonalCpuKernelMod : public NativeCpuKernelMod {
+ public:
+  FillDiagonalCpuKernelMod() = default;
+  ~FillDiagonalCpuKernelMod() override = default;
+
+  bool Init(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+  int Resize(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+  bool Launch(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &workspace,
+              const std::vector<KernelTensor *> &outputs) override;
+
+ protected:
+  std::vector<KernelAttr> GetOpSupport() override;
+
+ private:
+  template <typename T>
+  bool LaunchKernel(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs);
+  TypeId input_type_{kTypeUnknown};
+  std::vector<int64_t> input_shape_;
+  float fill_value_;
+  bool wrap_;
+};
+}  // namespace fill_diagonal_cpu
+}  // namespace kernel
+}  // namespace mindspore
+
+#endif  // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FILL_DIAGONAL_CPU_KERNEL_H_

mindspore/include/mindspore/ops/kernel/cpu/native/fill_v2_cpu_kernel.h

@@ -0,0 +1,57 @@
+/**
+ * Copyright 2022 Huawei Technologies Co., Ltd
+ *
+ * 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.
+ */
+
+#ifndef MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FILL_V2_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FILL_V2_CPU_KERNEL_H_
+
+#include <vector>
+#include <utility>
+#include "kernel/cpu/cpu_kernel.h"
+#include "include/runtime/hardware_abstract/kernel_base/ms_factory.h"
+
+namespace mindspore {
+namespace kernel {
+namespace fill_v2_cpu {
+class FillV2CpuKernelMod : public NativeCpuKernelMod {
+ public:
+  FillV2CpuKernelMod() = default;
+  ~FillV2CpuKernelMod() override = default;
+
+  bool Init(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  bool Launch(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &workspace,
+              const std::vector<KernelTensor *> &outputs) override {
+    return kernel_func_(this, inputs, workspace, outputs);
+  }
+
+ protected:
+  std::vector<KernelAttr> GetOpSupport() override;
+
+ private:
+  template <typename T>
+  bool LaunchKernel(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &workspace,
+                    const std::vector<KernelTensor *> &outputs);
+
+  using FillV2LaunchFunc =
+    std::function<bool(FillV2CpuKernelMod *, const std::vector<KernelTensor *> &, const std::vector<KernelTensor *> &,
+                       const std::vector<KernelTensor *> &)>;
+  static std::vector<std::pair<KernelAttr, FillV2LaunchFunc>> func_list_;
+  FillV2LaunchFunc kernel_func_;
+};
+}  // namespace fill_v2_cpu
+}  // namespace kernel
+}  // namespace mindspore
+#endif  // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FILL_V2_CPU_KERNEL_H_

mindspore/include/mindspore/ops/kernel/cpu/native/fmax_cpu_kernel.h

@@ -0,0 +1,93 @@
+/**
+ * Copyright 2022 Huawei Technologies Co., Ltd
+ *
+ * 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.
+ */
+
+#ifndef MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FMAX_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FMAX_CPU_KERNEL_H_
+
+#include <map>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "kernel/cpu/cpu_kernel.h"
+#include "include/runtime/hardware_abstract/kernel_base/ms_factory.h"
+
+namespace mindspore {
+namespace kernel {
+namespace fmax_cpu {
+class FmaxCpuKernelMod : public NativeCpuKernelMod, public MatchKernelHelper<FmaxCpuKernelMod> {
+ public:
+  FmaxCpuKernelMod() = default;
+  ~FmaxCpuKernelMod() override = default;
+
+  bool Init(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  int Resize(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  bool Launch(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &workspace,
+              const std::vector<KernelTensor *> &outputs) override {
+    return kernel_func_(this, inputs, workspace, outputs);
+  }
+  const std::vector<std::pair<KernelAttr, KernelRunFunc>> &GetFuncList() const override;
+
+ protected:
+  std::vector<KernelAttr> GetOpSupport() override;
+
+ private:
+  bool IsBroadcast() const;
+  int64_t Index(const int64_t &index, const int64_t &dim) const;
+  void InitTensorBroadcastShape();
+  void InitInputTensorAndScalar(size_t max_input_shape_size);
+  void InitInputTensors(TypeId input_x_dtype, TypeId input_y_dtype);
+
+  // Broadcast Arithmetic
+  template <typename T>
+  void BroadcastArithKernel(const size_t l0, const size_t l1, const size_t l2, const size_t l3, const size_t l4,
+                            const size_t l5, const size_t l6, const size_t r0, const size_t r1, const size_t r2,
+                            const size_t r3, const size_t r4, const size_t r5, const size_t r6, const size_t d0,
+                            const size_t d1, const size_t d2, const size_t d3, const size_t d4, const size_t d5,
+                            const size_t d6, const T *input_x, const T *input_y, T *output) const;
+
+  template <typename T>
+  T FmaxFunc(const T &lhs, const T &rhs) const;
+  template <typename T>
+  void BroadcastArithOneScalarOneTensor(const T *input_x, const T *input_y, T *output) const;
+  template <typename T>
+  void BroadcastArithTensors(const T *input_x, const T *input_y, T *output) const;
+  template <typename T>
+  void BroadcastArith(const T *input_x, const T *input_y, T *output) const;
+  template <typename T>
+  bool LaunchKernel(const std::vector<kernel::KernelTensor *> &inputs,
+                    const std::vector<kernel::KernelTensor *> &workspace,
+                    const std::vector<kernel::KernelTensor *> &outputs) const;
+
+  bool need_broadcast_{false};
+  size_t input_x_num_{1};
+  size_t input_y_num_{1};
+  size_t output_num_{1};
+  std::vector<int64_t> input_x_shape_;
+  std::vector<int64_t> input_y_shape_;
+  std::vector<int64_t> output_shape_;
+  std::vector<int64_t> broadcast_input_x_shape_;
+  std::vector<int64_t> broadcast_input_y_shape_;
+  std::vector<int64_t> broadcast_output_shape_;
+  const size_t max_dims_{7};
+};
+}  // namespace fmax_cpu
+}  // namespace kernel
+}  // namespace mindspore
+
+#endif  // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FMAX_CPU_KERNEL_H_

mindspore/include/mindspore/ops/kernel/cpu/native/fmin_cpu_kernel.h

@@ -0,0 +1,93 @@
+/**
+ * Copyright 2022 Huawei Technologies Co., Ltd
+ *
+ * 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.
+ */
+
+#ifndef MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FMIN_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FMIN_CPU_KERNEL_H_
+
+#include <map>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "kernel/cpu/cpu_kernel.h"
+#include "include/runtime/hardware_abstract/kernel_base/ms_factory.h"
+
+namespace mindspore {
+namespace kernel {
+namespace fmin_cpu {
+class FminCpuKernelMod : public NativeCpuKernelMod, public MatchKernelHelper<FminCpuKernelMod> {
+ public:
+  FminCpuKernelMod() = default;
+  ~FminCpuKernelMod() override = default;
+
+  bool Init(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  int Resize(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  bool Launch(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &workspace,
+              const std::vector<KernelTensor *> &outputs) override {
+    return kernel_func_(this, inputs, workspace, outputs);
+  }
+  const std::vector<std::pair<KernelAttr, KernelRunFunc>> &GetFuncList() const override;
+
+ protected:
+  std::vector<KernelAttr> GetOpSupport() override;
+
+ private:
+  bool IsBroadcast() const;
+  int64_t Index(const int64_t &index, const int64_t &dim) const;
+  void InitTensorBroadcastShape();
+  void InitInputTensorAndScalar(size_t max_input_shape_size);
+  void InitInputTensors(TypeId input_x_dtype, TypeId input_y_dtype);
+
+  // Broadcast Arithmetic
+  template <typename T>
+  void BroadcastArithKernel(const size_t l0, const size_t l1, const size_t l2, const size_t l3, const size_t l4,
+                            const size_t l5, const size_t l6, const size_t r0, const size_t r1, const size_t r2,
+                            const size_t r3, const size_t r4, const size_t r5, const size_t r6, const size_t d0,
+                            const size_t d1, const size_t d2, const size_t d3, const size_t d4, const size_t d5,
+                            const size_t d6, const T *input_x, const T *input_y, T *output) const;
+
+  template <typename T>
+  T FminFunc(const T &lhs, const T &rhs) const;
+  template <typename T>
+  void BroadcastArithOneScalarOneTensor(const T *input_x, const T *input_y, T *output) const;
+  template <typename T>
+  void BroadcastArithTensors(const T *input_x, const T *input_y, T *output) const;
+  template <typename T>
+  void BroadcastArith(const T *input_x, const T *input_y, T *output) const;
+  template <typename T>
+  bool LaunchKernel(const std::vector<kernel::KernelTensor *> &inputs,
+                    const std::vector<kernel::KernelTensor *> &workspace,
+                    const std::vector<kernel::KernelTensor *> &outputs) const;
+
+  bool need_broadcast_{false};
+  size_t input_x_num_{1};
+  size_t input_y_num_{1};
+  size_t output_num_{1};
+  std::vector<int64_t> input_x_shape_;
+  std::vector<int64_t> input_y_shape_;
+  std::vector<int64_t> output_shape_;
+  std::vector<int64_t> broadcast_input_x_shape_;
+  std::vector<int64_t> broadcast_input_y_shape_;
+  std::vector<int64_t> broadcast_output_shape_;
+  const size_t max_dims_{7};
+};
+}  // namespace fmin_cpu
+}  // namespace kernel
+}  // namespace mindspore
+
+#endif  // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FMIN_CPU_KERNEL_H_

mindspore/include/mindspore/ops/kernel/cpu/native/fractional_avg_pool_cpu_kernel.h

@@ -0,0 +1,72 @@
+/**
+ * Copyright 2021 Huawei Technologies Co., Ltd
+ *
+ * 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.
+ */
+
+#ifndef MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FRACTIONAL_AVG_POOL_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FRACTIONAL_AVG_POOL_CPU_KERNEL_H_
+
+#include <memory>
+#include <map>
+#include <unordered_map>
+#include <vector>
+#include <random>
+#include <algorithm>
+#include <utility>
+#include "kernel/cpu/cpu_kernel.h"
+#include "include/runtime/hardware_abstract/kernel_base/ms_factory.h"
+
+namespace mindspore {
+namespace kernel {
+namespace fractional_avg_pool_cpu {
+class FractionalAvgPoolCpuKernelMod : public NativeCpuKernelMod {
+ public:
+  FractionalAvgPoolCpuKernelMod() = default;
+  ~FractionalAvgPoolCpuKernelMod() override = default;
+
+  bool Init(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  int Resize(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  bool Launch(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &,
+              const std::vector<KernelTensor *> &outputs) override {
+    return kernel_func_(this, inputs, outputs);
+  }
+
+  std::vector<KernelAttr> GetOpSupport() override;
+
+ private:
+  template <typename T>
+  bool FractionalAvgPoolLaunch(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs);
+  template <typename T>
+  bool FractionalAvgPoolDoCompute(const T *input_ptr, T *output_ptr, size_t b, size_t hs, const int64_t height_start,
+                                  int64_t height_end, std::vector<int64_t> width_cum_seq);
+  using FractionalAvgPoolFunc =
+    std::function<bool(FractionalAvgPoolCpuKernelMod *, const std::vector<kernel::KernelTensor *> &,
+                       const std::vector<kernel::KernelTensor *> &)>;
+  static std::vector<std::pair<KernelAttr, FractionalAvgPoolFunc>> func_list_;
+  FractionalAvgPoolFunc kernel_func_;
+  std::vector<int64_t> input_shape_;
+  std::vector<int64_t> output_shape_;
+  std::vector<float> pooling_ratio_;
+  bool pseudo_random_{false};
+  bool overlapping_{false};
+  bool deterministic_{false};
+  int seed_{0};
+  int seed2_{0};
+};
+}  // namespace fractional_avg_pool_cpu
+}  // namespace kernel
+}  // namespace mindspore
+#endif  // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FRACTIONAL_AVG_POOL_CPU_KERNEL_H_

mindspore/include/mindspore/ops/kernel/cpu/native/fractional_avg_pool_grad_cpu_kernel.h

@@ -0,0 +1,78 @@
+/**
+ * Copyright 2021 Huawei Technologies Co., Ltd
+ *
+ * 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.
+ */
+
+#ifndef MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FRACTIONAL_AVG_POOL_GRAD_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FRACTIONAL_AVG_POOL_GRAD_CPU_KERNEL_H_
+
+#include <memory>
+#include <unordered_map>
+#include <vector>
+#include <random>
+#include <algorithm>
+#include <utility>
+#include <map>
+#include "Eigen/Core"
+#include "kernel/cpu/cpu_kernel.h"
+#include "include/runtime/hardware_abstract/kernel_base/ms_factory.h"
+
+namespace mindspore {
+namespace kernel {
+namespace fractional_avg_pool_grad_cpu {
+class FractionalAvgPoolGradCpuKernelMod : public NativeCpuKernelMod {
+ public:
+  FractionalAvgPoolGradCpuKernelMod() : kernel_func_(nullptr) {}
+  ~FractionalAvgPoolGradCpuKernelMod() override = default;
+
+  bool Init(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  int Resize(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  bool Launch(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &,
+              const std::vector<KernelTensor *> &outputs) override {
+    return kernel_func_(this, inputs, outputs);
+  }
+
+ protected:
+  bool IsNeedUpdateOutputShapeAndSize() override { return true; }
+  void UpdateOutputShapeAndSize(const std::vector<KernelTensor *> &inputs,
+                                const std::vector<KernelTensor *> &outputs) override;
+
+  std::vector<KernelAttr> GetOpSupport() override;
+
+ private:
+  template <typename T>
+  bool FractionalAvgPoolGradLaunch(const std::vector<KernelTensor *> &inputs,
+                                   const std::vector<KernelTensor *> &outputs);
+  template <typename T>
+  void FractionalAvgPoolGradCompute(
+    const int64_t out_cols, const int64_t *col_seq, const int64_t height_start, int64_t height_end, int64_t b,
+    int64_t hs, const int64_t out_rows, const int64_t out_depth, const int64_t in_rows, const int64_t in_cols,
+    const Eigen::Map<const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>> &out_backprop_mat,
+    Eigen::Map<Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>> in_backprop_tensor_temp_mat);
+  using FractionalAvgPoolGradFunc =
+    std::function<bool(FractionalAvgPoolGradCpuKernelMod *, const std::vector<kernel::KernelTensor *> &,
+                       const std::vector<kernel::KernelTensor *> &)>;
+  static std::vector<std::pair<KernelAttr, FractionalAvgPoolGradFunc>> func_list_;
+  FractionalAvgPoolGradFunc kernel_func_;
+  std::vector<int64_t> orig_input_shape_;
+  std::vector<int64_t> out_backprop_shape_;
+  bool overlapping_{false};
+  ShapeVector out_shape_{};
+};
+}  // namespace fractional_avg_pool_grad_cpu
+}  // namespace kernel
+}  // namespace mindspore
+#endif  // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FRACTIONAL_AVG_POOL_GRAD_CPU_KERNEL_H_

mindspore/include/mindspore/ops/kernel/cpu/native/fractional_max_pool3d_grad_with_fixed_ksize_cpu_kernel.h

@@ -0,0 +1,70 @@
+/**
+ * Copyright 2021 Huawei Technologies Co., Ltd
+ *
+ * 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.
+ */
+#ifndef MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FRACTIONAL_MAX_POOL3D_GRAD_WITH_FIXED_KSIZE_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FRACTIONAL_MAX_POOL3D_GRAD_WITH_FIXED_KSIZE_CPU_KERNEL_H_
+#include <memory>
+#include <vector>
+#include <string>
+#include <map>
+#include "kernel/cpu/cpu_kernel.h"
+#include "include/runtime/hardware_abstract/kernel_base/ms_factory.h"
+
+namespace mindspore {
+namespace kernel {
+namespace fractional_max_pool3d_grad_with_fixed_ksize_cpu {
+class FractionalMaxPool3DGradWithFixedKsizeCPUKernelMod : public NativeCpuKernelMod {
+ public:
+  FractionalMaxPool3DGradWithFixedKsizeCPUKernelMod() = default;
+  ~FractionalMaxPool3DGradWithFixedKsizeCPUKernelMod() override = default;
+
+  bool Init(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  int Resize(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  bool Launch(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &workspace,
+              const std::vector<KernelTensor *> &outputs) override;
+
+  std::vector<KernelAttr> GetOpSupport() override;
+
+ private:
+  template <typename backprop_t, typename argmax_t>
+  bool GradComputeTemplate(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs);
+  template <typename backprop_t>
+  bool DoComputeWithArgmaxType(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs,
+                               TypeId argmax_type);
+  std::vector<int64_t> input_shape_;
+  std::vector<int64_t> out_backprop_shape_;
+  std::vector<int64_t> argmax_shape_;
+  std::string data_format_;
+  TypeId out_backprop_type_;
+  TypeId argmax_type_;
+  int64_t c_dim_;
+  int64_t d_dim_;
+  int64_t h_dim_;
+  int64_t w_dim_;
+  int64_t inputN_;
+  int64_t inputC_;
+  int64_t inputD_;
+  int64_t inputH_;
+  int64_t inputW_;
+  int64_t outputD_;
+  int64_t outputH_;
+  int64_t outputW_;
+};
+}  // namespace fractional_max_pool3d_grad_with_fixed_ksize_cpu
+}  // namespace kernel
+}  // namespace mindspore
+#endif  // MINDSPORE_CCSRC_BACKEND_KERNEL_COMPILER_CPU_FRACTIONAL_MAX_POOL3D_GRAD_WITH_FIXED_KSIZE_CPU_KERNEL_H_

mindspore/include/mindspore/ops/kernel/cpu/native/fractional_max_pool3d_with_fixed_ksize_cpu_kernel.h

@@ -0,0 +1,79 @@
+/**
+ * Copyright 2021 Huawei Technologies Co., Ltd
+ *
+ * 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.
+ */
+#ifndef MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_FRACTIONAL_MAX_POOL3D_WITH_FIXED_KSIZE_CPU_KERNEL_H_
+#define MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_FRACTIONAL_MAX_POOL3D_WITH_FIXED_KSIZE_CPU_KERNEL_H_
+#include <map>
+#include <memory>
+#include <vector>
+#include <string>
+#include "kernel/cpu/cpu_kernel.h"
+#include "include/runtime/hardware_abstract/kernel_base/ms_factory.h"
+#include "mindspore/ops/infer/fractional_max_pool3d_with_fixed_ksize.h"
+
+namespace mindspore {
+namespace kernel {
+namespace fractional_max_pool3d_with_fixed_ksize_cpu {
+class FractionalMaxPool3DWithFixedKsizeCPUKernelMod : public NativeCpuKernelMod {
+ public:
+  FractionalMaxPool3DWithFixedKsizeCPUKernelMod() = default;
+  ~FractionalMaxPool3DWithFixedKsizeCPUKernelMod() override = default;
+
+  bool Init(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+  bool Launch(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &workspace,
+              const std::vector<KernelTensor *> &outputs) override;
+  int Resize(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs) override;
+
+  std::vector<KernelAttr> GetOpSupport() override;
+
+ private:
+  template <typename scalar_t, typename random_sample_t, typename argmax_t>
+  bool ComputeTemplate(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs);
+  template <typename scalar_t, typename random_sample_t, typename argmax_t>
+  bool FractionalMaxPool3DWithFixedKsizeCompute(scalar_t *inputForPlane, random_sample_t *random_samplesForPlane,
+                                                argmax_t *argmaxForPlane, scalar_t *outputForPlane, int64_t outputD,
+                                                int64_t outputH, int64_t outputW, int64_t kernelsizeD,
+                                                int64_t kernelsizeH, int64_t kernelsizeW, int64_t inputC,
+                                                int64_t inputD, int64_t inputH, int64_t inputW);
+  template <typename scalar_t, typename random_sample_t>
+  bool DoComputeWithArgmaxType(const std::vector<KernelTensor *> &inputs, const std::vector<KernelTensor *> &outputs,
+                               TypeId argmax_type);
+  template <typename scalar_t>
+  bool DoComputeWithRandomSamplesType(const std::vector<KernelTensor *> &inputs,
+                                      const std::vector<KernelTensor *> &outputs, TypeId random_samples_type);
+  std::vector<int64_t> input_shape_;
+  std::vector<int64_t> random_samples_shape_;
+  std::vector<int64_t> output_shape_;
+  std::vector<int64_t> ksize_;
+  std::string data_format_;
+  TypeId input_type_;
+  TypeId random_samples_type_;
+  TypeId argmax_type_;
+  int64_t inputN_;
+  int64_t inputC_;
+  int64_t inputD_;
+  int64_t inputH_;
+  int64_t inputW_;
+  int64_t outputD_;
+  int64_t outputH_;
+  int64_t outputW_;
+  int64_t kernelsizeD_;
+  int64_t kernelsizeH_;
+  int64_t kernelsizeW_;
+};
+}  // namespace fractional_max_pool3d_with_fixed_ksize_cpu
+}  // namespace kernel
+}  // namespace mindspore
+#endif  // MINDSPORE_CCSRC_PLUGIN_DEVICE_CPU_FRACTIONAL_MAX_POOL3D_WITH_FIXED_KSIZE_CPU_KERNEL_H_