Merge pull request #1111 from InfiniTensor/issue/1031_T1-1-49

【比赛2025秋】T1-1-49

Author: PanZezhong1725

include/infinicore/ops/log_softmax.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class LogSoftmax {
+public:
+    // Schema signature: output(out), input, dim
+    using schema = void (*)(Tensor, Tensor, int64_t);
+
+    static void execute(Tensor output, Tensor input, int64_t dim);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+// Functional API: Returns the result tensor
+Tensor log_softmax(Tensor input, int64_t dim);
+
+// In-place/Output-provided API
+void log_softmax_(Tensor output, Tensor input, int64_t dim);
+
+} // namespace infinicore::op

include/infinicore/ops/logaddexp.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class LogAddExp {
+public:
+    using schema = void (*)(Tensor, Tensor, Tensor);
+    static void execute(Tensor c, Tensor a, Tensor b);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor logaddexp(Tensor a, Tensor b);
+void logaddexp_(Tensor c, Tensor a, Tensor b);
+
+} // namespace infinicore::op

include/infinicore/ops/logaddexp2.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class LogAddExp2 {
+public:
+    using schema = void (*)(Tensor, Tensor, Tensor);
+    static void execute(Tensor c, Tensor a, Tensor b);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor logaddexp2(Tensor a, Tensor b);
+void logaddexp2_(Tensor c, Tensor a, Tensor b);
+
+} // namespace infinicore::op

include/infinicore/ops/triplet_margin_with_distance_loss.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class TripletMarginWithDistanceLoss {
+public:
+    // Schema signature: output(out), anchor, positive, negative, margin, swap, reduction
+    using schema = void (*)(Tensor, Tensor, Tensor, Tensor, double, bool, int64_t);
+
+    static void execute(Tensor output, Tensor anchor, Tensor positive, Tensor negative, double margin, bool swap, int64_t reduction);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+// Functional API: Returns the result tensor
+// margin default 1.0, swap default false, reduction default 1 (Mean) typically
+Tensor triplet_margin_with_distance_loss(Tensor anchor, Tensor positive, Tensor negative, double margin = 1.0, bool swap = false, int64_t reduction = 1);
+
+// In-place/Output-provided API
+void triplet_margin_with_distance_loss_(Tensor output, Tensor anchor, Tensor positive, Tensor negative, double margin, bool swap, int64_t reduction);
+
+} // namespace infinicore::op

include/infinicore/ops/upsample_nearest.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+#include <vector>
+
+namespace infinicore::op {
+
+class UpsampleNearest {
+public:
+    // Schema signature: output(out), input
+    // Note: Scales are inferred from output.shape / input.shape
+    using schema = void (*)(Tensor, Tensor);
+
+    static void execute(Tensor output, Tensor input);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+// Functional API: Returns the result tensor
+// Requires output_size to calculate the shape of the result tensor
+Tensor upsample_nearest(Tensor input, const std::vector<int64_t> &output_size);
+
+// In-place/Output-provided API
+void upsample_nearest_(Tensor output, Tensor input);
+
+} // namespace infinicore::op

include/infiniop.h

@@ -52,7 +52,9 @@
 #include "infiniop/ops/layer_norm.h"
 #include "infiniop/ops/ldexp.h"
 #include "infiniop/ops/lerp.h"
-#include "infiniop/ops/logsoftmax.h"
+#include "infiniop/ops/log_softmax.h"
+#include "infiniop/ops/logaddexp.h"
+#include "infiniop/ops/logaddexp2.h"
 #include "infiniop/ops/lp_norm.h"
 #include "infiniop/ops/masked_select.h"
 #include "infiniop/ops/mul.h"
@@ -88,7 +90,9 @@
 #include "infiniop/ops/topkrouter.h"
 #include "infiniop/ops/topksoftmax.h"
 #include "infiniop/ops/triplet_margin_loss.h"
+#include "infiniop/ops/triplet_margin_with_distance_loss.h"
 #include "infiniop/ops/upsample_bilinear.h"
+#include "infiniop/ops/upsample_nearest.h"
 #include "infiniop/ops/var.h"
 #include "infiniop/ops/var_mean.h"
 #include "infiniop/ops/zeros.h"

include/infiniop/ops/logsoftmax.h include/infiniop/ops/log_softmax.hinclude/infiniop/ops/logsoftmax.h renamed to include/infiniop/ops/log_softmax.h

@@ -1,24 +1,25 @@
-#ifndef __INFINIOP_LOGSOFTMAX_API_H__
-#define __INFINIOP_LOGSOFTMAX_API_H__
+#ifndef __INFINIOP_LOG_SOFTMAX_API_H__
+#define __INFINIOP_LOG_SOFTMAX_API_H__
 
 #include "../operator_descriptor.h"
 
 typedef struct InfiniopDescriptor *infiniopLogSoftmaxDescriptor_t;
 
 __INFINI_C __export infiniStatus_t infiniopCreateLogSoftmaxDescriptor(infiniopHandle_t handle,
-                                                                  infiniopLogSoftmaxDescriptor_t *desc_ptr,
-                                                                  infiniopTensorDescriptor_t y_desc,
-                                                                  infiniopTensorDescriptor_t x_desc);
+                                                               infiniopLogSoftmaxDescriptor_t *desc_ptr,
+                                                               infiniopTensorDescriptor_t output,
+                                                               infiniopTensorDescriptor_t input,
+                                                               int dim);
 
 __INFINI_C __export infiniStatus_t infiniopGetLogSoftmaxWorkspaceSize(infiniopLogSoftmaxDescriptor_t desc, size_t *size);
 
 __INFINI_C __export infiniStatus_t infiniopLogSoftmax(infiniopLogSoftmaxDescriptor_t desc,
                                                void *workspace,
                                                size_t workspace_size,
-                                               void *y,
-                                               const void *x,
+                                               void *output,
+                                               const void *input,
                                                void *stream);
 
 __INFINI_C __export infiniStatus_t infiniopDestroyLogSoftmaxDescriptor(infiniopLogSoftmaxDescriptor_t desc);
 
-#endif
+#endif // __INFINIOP_LOG_SOFTMAX_API_H__

include/infiniop/ops/logaddexp.h

@@ -0,0 +1,26 @@
+#ifndef __INFINIOP_LOGADDEXP_API_H__
+#define __INFINIOP_LOGADDEXP_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopLogAddExpDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateLogAddExpDescriptor(infiniopHandle_t handle,
+                                                                     infiniopLogAddExpDescriptor_t *desc_ptr,
+                                                                     infiniopTensorDescriptor_t c,
+                                                                     infiniopTensorDescriptor_t a,
+                                                                     infiniopTensorDescriptor_t b);
+
+__INFINI_C __export infiniStatus_t infiniopGetLogAddExpWorkspaceSize(infiniopLogAddExpDescriptor_t desc, size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopLogAddExp(infiniopLogAddExpDescriptor_t desc,
+                                                     void *workspace,
+                                                     size_t workspace_size,
+                                                     void *c,
+                                                     const void *a,
+                                                     const void *b,
+                                                     void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyLogAddExpDescriptor(infiniopLogAddExpDescriptor_t desc);
+
+#endif // __INFINIOP_LOGADDEXP_API_H__

include/infiniop/ops/logaddexp2.h

@@ -0,0 +1,26 @@
+#ifndef __INFINIOP_LOGADDEXP2_API_H__
+#define __INFINIOP_LOGADDEXP2_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopLogAddExp2Descriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateLogAddExp2Descriptor(infiniopHandle_t handle,
+                                                                      infiniopLogAddExp2Descriptor_t *desc_ptr,
+                                                                      infiniopTensorDescriptor_t c,
+                                                                      infiniopTensorDescriptor_t a,
+                                                                      infiniopTensorDescriptor_t b);
+
+__INFINI_C __export infiniStatus_t infiniopGetLogAddExp2WorkspaceSize(infiniopLogAddExp2Descriptor_t desc, size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopLogAddExp2(infiniopLogAddExp2Descriptor_t desc,
+                                                      void *workspace,
+                                                      size_t workspace_size,
+                                                      void *c,
+                                                      const void *a,
+                                                      const void *b,
+                                                      void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyLogAddExp2Descriptor(infiniopLogAddExp2Descriptor_t desc);
+
+#endif // __INFINIOP_LOGADDEXP2_API_H__

include/infiniop/ops/triplet_margin_with_distance_loss.h

@@ -0,0 +1,32 @@
+#ifndef __INFINIOP_TRIPLET_MARGIN_WITH_DISTANCE_LOSS_API_H__
+#define __INFINIOP_TRIPLET_MARGIN_WITH_DISTANCE_LOSS_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopTripletMarginWithDistanceLossDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateTripletMarginWithDistanceLossDescriptor(
+    infiniopHandle_t handle,
+    infiniopTripletMarginWithDistanceLossDescriptor_t *desc_ptr,
+    infiniopTensorDescriptor_t output,
+    infiniopTensorDescriptor_t anchor,
+    infiniopTensorDescriptor_t positive,
+    infiniopTensorDescriptor_t negative,
+    float margin,
+    int swap,
+    int reduction);
+__INFINI_C __export infiniStatus_t infiniopGetTripletMarginWithDistanceLossWorkspaceSize(
+    infiniopTripletMarginWithDistanceLossDescriptor_t desc,
+    size_t *size);
+__INFINI_C __export infiniStatus_t infiniopTripletMarginWithDistanceLoss(infiniopTripletMarginWithDistanceLossDescriptor_t desc,
+                                                                         void *workspace,
+                                                                         size_t workspace_size,
+                                                                         void *output,
+                                                                         const void *anchor,
+                                                                         const void *positive,
+                                                                         const void *negative,
+                                                                         void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyTripletMarginWithDistanceLossDescriptor(
+    infiniopTripletMarginWithDistanceLossDescriptor_t desc);
+#endif // __INFINIOP_TRIPLET_MARGIN_WITH_DISTANCE_LOSS_API_H__