Implement T1-1-30: interpolate interpolate gaussian_nll_loss gaussia…

.gitignore

@@ -32,3 +32,6 @@ cache/
 *.gz
 *.zip
 *.tar
+
+# Humanize RLCR loop state
+.humanize/

include/infinicore/ops/bitwise_right_shift.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "infinicore.h"
+
+#include "../device.hpp"
+#include "../graph/graph.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+INFINICORE_GRAPH_OP_CLASS(BitwiseRightShift, Tensor, const Tensor &, const Tensor &);
+
+__export Tensor bitwise_right_shift(const Tensor &input, const Tensor &other);
+__export void bitwise_right_shift_(Tensor out, const Tensor &input, const Tensor &other);
+
+} // namespace infinicore::op

include/infinicore/ops/gaussian_nll_loss.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "infinicore.h"
+
+#include "../device.hpp"
+#include "../graph/graph.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+INFINICORE_GRAPH_OP_CLASS(GaussianNllLoss, Tensor, const Tensor &, const Tensor &, const Tensor &, bool, double, int);
+
+__export Tensor gaussian_nll_loss(const Tensor &input,
+                                 const Tensor &target,
+                                 const Tensor &var,
+                                 bool full = false,
+                                 double eps = 1e-6,
+                                 int reduction = 1);
+
+__export void gaussian_nll_loss_(Tensor out,
+                                const Tensor &input,
+                                const Tensor &target,
+                                const Tensor &var,
+                                bool full = false,
+                                double eps = 1e-6,
+                                int reduction = 1);
+
+} // namespace infinicore::op

include/infinicore/ops/interpolate.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "infinicore.h"
+
+#include "../device.hpp"
+#include "../graph/graph.hpp"
+#include "common/op.hpp"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace infinicore::op {
+
+INFINICORE_GRAPH_OP_CLASS(Interpolate, Tensor, const Tensor &, std::string, std::vector<int64_t>, std::vector<double>, int);
+
+__export Tensor interpolate(const Tensor &input,
+                           std::string mode,
+                           std::vector<int64_t> size,
+                           std::vector<double> scale_factor,
+                           int align_corners);
+
+__export void interpolate_(Tensor out,
+                          const Tensor &input,
+                          std::string mode,
+                          std::vector<int64_t> size,
+                          std::vector<double> scale_factor,
+                          int align_corners);
+
+} // namespace infinicore::op

include/infinicore/ops/prelu.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "infinicore.h"
+
+#include "../device.hpp"
+#include "../graph/graph.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+INFINICORE_GRAPH_OP_CLASS(Prelu, Tensor, const Tensor &, const Tensor &);
+
+__export Tensor prelu(const Tensor &input, const Tensor &weight);
+__export void prelu_(Tensor out, const Tensor &input, const Tensor &weight);
+
+} // namespace infinicore::op

include/infinicore/ops/relu6.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "infinicore.h"
+
+#include "../device.hpp"
+#include "../graph/graph.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+INFINICORE_GRAPH_OP_CLASS(Relu6, Tensor, const Tensor &);
+
+__export Tensor relu6(const Tensor &input);
+__export void relu6_(Tensor out, const Tensor &input);
+
+} // namespace infinicore::op

include/infiniop/ops/bitwise_right_shift.h

@@ -0,0 +1,26 @@
+#ifndef __INFINIOP_BITWISE_RIGHT_SHIFT_API_H__
+#define __INFINIOP_BITWISE_RIGHT_SHIFT_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopBitwiseRightShiftDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateBitwiseRightShiftDescriptor(infiniopHandle_t handle,
+                                                                      infiniopBitwiseRightShiftDescriptor_t *desc_ptr,
+                                                                      infiniopTensorDescriptor_t y,
+                                                                      infiniopTensorDescriptor_t x1,
+                                                                      infiniopTensorDescriptor_t x2);
+
+__C __export infiniStatus_t infiniopGetBitwiseRightShiftWorkspaceSize(infiniopBitwiseRightShiftDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopBitwiseRightShift(infiniopBitwiseRightShiftDescriptor_t desc,
+                                                      void *workspace,
+                                                      size_t workspace_size,
+                                                      void *y,
+                                                      const void *x1,
+                                                      const void *x2,
+                                                      void *stream);
+
+__C __export infiniStatus_t infiniopDestroyBitwiseRightShiftDescriptor(infiniopBitwiseRightShiftDescriptor_t desc);
+
+#endif

include/infiniop/ops/gaussian_nll_loss.h

@@ -0,0 +1,31 @@
+#ifndef __INFINIOP_GAUSSIAN_NLL_LOSS_API_H__
+#define __INFINIOP_GAUSSIAN_NLL_LOSS_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopGaussianNllLossDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateGaussianNllLossDescriptor(infiniopHandle_t handle,
+                                                                    infiniopGaussianNllLossDescriptor_t *desc_ptr,
+                                                                    infiniopTensorDescriptor_t y,
+                                                                    infiniopTensorDescriptor_t input,
+                                                                    infiniopTensorDescriptor_t target,
+                                                                    infiniopTensorDescriptor_t var,
+                                                                    int full,
+                                                                    double eps,
+                                                                    int reduction);
+
+__C __export infiniStatus_t infiniopGetGaussianNllLossWorkspaceSize(infiniopGaussianNllLossDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopGaussianNllLoss(infiniopGaussianNllLossDescriptor_t desc,
+                                                    void *workspace,
+                                                    size_t workspace_size,
+                                                    void *y,
+                                                    const void *input,
+                                                    const void *target,
+                                                    const void *var,
+                                                    void *stream);
+
+__C __export infiniStatus_t infiniopDestroyGaussianNllLossDescriptor(infiniopGaussianNllLossDescriptor_t desc);
+
+#endif

include/infiniop/ops/interpolate.h

@@ -0,0 +1,28 @@
+#ifndef __INFINIOP_INTERPOLATE_API_H__
+#define __INFINIOP_INTERPOLATE_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopInterpolateDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateInterpolateDescriptor(infiniopHandle_t handle,
+                                                                infiniopInterpolateDescriptor_t *desc_ptr,
+                                                                infiniopTensorDescriptor_t y,
+                                                                infiniopTensorDescriptor_t x,
+                                                                const char *mode,
+                                                                void *size,
+                                                                void *scale_factor,
+                                                                int align_corners);
+
+__C __export infiniStatus_t infiniopGetInterpolateWorkspaceSize(infiniopInterpolateDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopInterpolate(infiniopInterpolateDescriptor_t desc,
+                                                void *workspace,
+                                                size_t workspace_size,
+                                                void *y,
+                                                const void *x,
+                                                void *stream);
+
+__C __export infiniStatus_t infiniopDestroyInterpolateDescriptor(infiniopInterpolateDescriptor_t desc);
+
+#endif

include/infiniop/ops/prelu.h

@@ -0,0 +1,26 @@
+#ifndef __INFINIOP_PRELU_API_H__
+#define __INFINIOP_PRELU_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopPreluDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreatePreluDescriptor(infiniopHandle_t handle,
+                                                          infiniopPreluDescriptor_t *desc_ptr,
+                                                          infiniopTensorDescriptor_t y,
+                                                          infiniopTensorDescriptor_t x,
+                                                          infiniopTensorDescriptor_t weight);
+
+__C __export infiniStatus_t infiniopGetPreluWorkspaceSize(infiniopPreluDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopPrelu(infiniopPreluDescriptor_t desc,
+                                          void *workspace,
+                                          size_t workspace_size,
+                                          void *y,
+                                          const void *x,
+                                          const void *weight,
+                                          void *stream);
+
+__C __export infiniStatus_t infiniopDestroyPreluDescriptor(infiniopPreluDescriptor_t desc);
+
+#endif

include/infiniop/ops/relu6.h

@@ -0,0 +1,24 @@
+#ifndef __INFINIOP_RELU6_API_H__
+#define __INFINIOP_RELU6_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopRelu6Descriptor_t;
+
+__C __export infiniStatus_t infiniopCreateRelu6Descriptor(infiniopHandle_t handle,
+                                                          infiniopRelu6Descriptor_t *desc_ptr,
+                                                          infiniopTensorDescriptor_t y,
+                                                          infiniopTensorDescriptor_t x);
+
+__C __export infiniStatus_t infiniopGetRelu6WorkspaceSize(infiniopRelu6Descriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopRelu6(infiniopRelu6Descriptor_t desc,
+                                          void *workspace,
+                                          size_t workspace_size,
+                                          void *y,
+                                          const void *x,
+                                          void *stream);
+
+__C __export infiniStatus_t infiniopDestroyRelu6Descriptor(infiniopRelu6Descriptor_t desc);
+
+#endif