Implement T1-1-31: selu selu block_diag block_diag kron kron hinge_e…

.gitignore

@@ -32,3 +32,7 @@ cache/
 *.gz
 *.zip
 *.tar
+
+# Humanize / RLCR
+.humanize/
+plan.md

include/infinicore/ops/block_diag.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+#include <vector>
+
+namespace infinicore::op {
+
+class BlockDiag {
+public:
+    using schema = void (*)(Tensor, const std::vector<Tensor> &);
+    static void execute(Tensor output, const std::vector<Tensor> &inputs);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor block_diag(const std::vector<Tensor> &inputs);
+void block_diag_(Tensor output, const std::vector<Tensor> &inputs);
+
+} // namespace infinicore::op
+

include/infinicore/ops/hinge_embedding_loss.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class HingeEmbeddingLoss {
+public:
+    using schema = void (*)(Tensor, Tensor, Tensor, double, int);
+    static void execute(Tensor output, Tensor input, Tensor target, double margin, int reduction);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor hinge_embedding_loss(Tensor input, Tensor target, double margin = 1.0, int reduction = 1);
+void hinge_embedding_loss_(Tensor output, Tensor input, Tensor target, double margin, int reduction);
+
+} // namespace infinicore::op
+

include/infinicore/ops/kron.hpp

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

include/infinicore/ops/selu.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class Selu {
+public:
+    using schema = void (*)(Tensor, Tensor);
+    static void execute(Tensor output, Tensor input);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor selu(Tensor input);
+void selu_(Tensor output, Tensor input);
+
+} // namespace infinicore::op
+

include/infinicore/ops/sinh.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class Sinh {
+public:
+    using schema = void (*)(Tensor, Tensor);
+    static void execute(Tensor output, Tensor input);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor sinh(Tensor input);
+void sinh_(Tensor output, Tensor input);
+
+} // namespace infinicore::op
+

include/infiniop.h

@@ -5,6 +5,7 @@
 #include "infiniop/ops/add.h"
 #include "infiniop/ops/add_rms_norm.h"
 #include "infiniop/ops/attention.h"
+#include "infiniop/ops/block_diag.h"
 #include "infiniop/ops/causal_softmax.h"
 #include "infiniop/ops/clip.h"
 #include "infiniop/ops/conv.h"
@@ -13,7 +14,9 @@
 #include "infiniop/ops/flash_attention.h"
 #include "infiniop/ops/gelu.h"
 #include "infiniop/ops/gemm.h"
+#include "infiniop/ops/hinge_embedding_loss.h"
 #include "infiniop/ops/int8_gemm.h"
+#include "infiniop/ops/kron.h"
 #include "infiniop/ops/kv_caching.h"
 #include "infiniop/ops/layer_norm.h"
 #include "infiniop/ops/logsoftmax.h"
@@ -29,7 +32,9 @@
 #include "infiniop/ops/relu.h"
 #include "infiniop/ops/rms_norm.h"
 #include "infiniop/ops/rope.h"
+#include "infiniop/ops/selu.h"
 #include "infiniop/ops/sigmoid.h"
+#include "infiniop/ops/sinh.h"
 #include "infiniop/ops/silu.h"
 #include "infiniop/ops/silu_and_mul.h"
 #include "infiniop/ops/softmax.h"

include/infiniop/ops/block_diag.h

@@ -0,0 +1,25 @@
+#ifndef __INFINIOP_BLOCK_DIAG_API_H__
+#define __INFINIOP_BLOCK_DIAG_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopBlockDiagDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateBlockDiagDescriptor(infiniopHandle_t handle,
+                                                              infiniopBlockDiagDescriptor_t *desc_ptr,
+                                                              infiniopTensorDescriptor_t y,
+                                                              infiniopTensorDescriptor_t *x,
+                                                              size_t num_inputs);
+
+__C __export infiniStatus_t infiniopGetBlockDiagWorkspaceSize(infiniopBlockDiagDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopBlockDiag(infiniopBlockDiagDescriptor_t desc,
+                                              void *workspace,
+                                              size_t workspace_size,
+                                              void *y,
+                                              const void **x,
+                                              void *stream);
+
+__C __export infiniStatus_t infiniopDestroyBlockDiagDescriptor(infiniopBlockDiagDescriptor_t desc);
+
+#endif

include/infiniop/ops/hinge_embedding_loss.h

@@ -0,0 +1,28 @@
+#ifndef __INFINIOP_HINGE_EMBEDDING_LOSS_API_H__
+#define __INFINIOP_HINGE_EMBEDDING_LOSS_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopHingeEmbeddingLossDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateHingeEmbeddingLossDescriptor(infiniopHandle_t handle,
+                                                                       infiniopHingeEmbeddingLossDescriptor_t *desc_ptr,
+                                                                       infiniopTensorDescriptor_t y,
+                                                                       infiniopTensorDescriptor_t input,
+                                                                       infiniopTensorDescriptor_t target,
+                                                                       double margin,
+                                                                       int reduction);
+
+__C __export infiniStatus_t infiniopGetHingeEmbeddingLossWorkspaceSize(infiniopHingeEmbeddingLossDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopHingeEmbeddingLoss(infiniopHingeEmbeddingLossDescriptor_t desc,
+                                                       void *workspace,
+                                                       size_t workspace_size,
+                                                       void *y,
+                                                       const void *input,
+                                                       const void *target,
+                                                       void *stream);
+
+__C __export infiniStatus_t infiniopDestroyHingeEmbeddingLossDescriptor(infiniopHingeEmbeddingLossDescriptor_t desc);
+
+#endif

include/infiniop/ops/kron.h

@@ -0,0 +1,26 @@
+#ifndef __INFINIOP_KRON_API_H__
+#define __INFINIOP_KRON_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopKronDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateKronDescriptor(infiniopHandle_t handle,
+                                                         infiniopKronDescriptor_t *desc_ptr,
+                                                         infiniopTensorDescriptor_t y,
+                                                         infiniopTensorDescriptor_t x1,
+                                                         infiniopTensorDescriptor_t x2);
+
+__C __export infiniStatus_t infiniopGetKronWorkspaceSize(infiniopKronDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopKron(infiniopKronDescriptor_t desc,
+                                         void *workspace,
+                                         size_t workspace_size,
+                                         void *y,
+                                         const void *x1,
+                                         const void *x2,
+                                         void *stream);
+
+__C __export infiniStatus_t infiniopDestroyKronDescriptor(infiniopKronDescriptor_t desc);
+
+#endif

include/infiniop/ops/selu.h

@@ -0,0 +1,24 @@
+#ifndef __INFINIOP_SELU_API_H__
+#define __INFINIOP_SELU_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopSeluDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateSeluDescriptor(infiniopHandle_t handle,
+                                                         infiniopSeluDescriptor_t *desc_ptr,
+                                                         infiniopTensorDescriptor_t y,
+                                                         infiniopTensorDescriptor_t x);
+
+__C __export infiniStatus_t infiniopGetSeluWorkspaceSize(infiniopSeluDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopSelu(infiniopSeluDescriptor_t desc,
+                                         void *workspace,
+                                         size_t workspace_size,
+                                         void *y,
+                                         const void *x,
+                                         void *stream);
+
+__C __export infiniStatus_t infiniopDestroySeluDescriptor(infiniopSeluDescriptor_t desc);
+
+#endif

include/infiniop/ops/sinh.h

@@ -0,0 +1,24 @@
+#ifndef __INFINIOP_SINH_API_H__
+#define __INFINIOP_SINH_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopSinhDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateSinhDescriptor(infiniopHandle_t handle,
+                                                         infiniopSinhDescriptor_t *desc_ptr,
+                                                         infiniopTensorDescriptor_t y,
+                                                         infiniopTensorDescriptor_t x);
+
+__C __export infiniStatus_t infiniopGetSinhWorkspaceSize(infiniopSinhDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopSinh(infiniopSinhDescriptor_t desc,
+                                         void *workspace,
+                                         size_t workspace_size,
+                                         void *y,
+                                         const void *x,
+                                         void *stream);
+
+__C __export infiniStatus_t infiniopDestroySinhDescriptor(infiniopSinhDescriptor_t desc);
+
+#endif