【比赛2025秋】T1-1-8

include/infinicore/ops.hpp

@@ -4,6 +4,7 @@
 #include "ops/add.hpp"
 #include "ops/add_rms_norm.hpp"
 #include "ops/addcmul.hpp"
+#include "ops/asin.hpp"
 #include "ops/asinh.hpp"
 #include "ops/atanh.hpp"
 #include "ops/attention.hpp"
@@ -16,6 +17,7 @@
 #include "ops/cross_entropy.hpp"
 #include "ops/embedding.hpp"
 #include "ops/flash_attention.hpp"
+#include "ops/fmin.hpp"
 #include "ops/fmod.hpp"
 #include "ops/hardswish.hpp"
 #include "ops/hardtanh.hpp"

include/infinicore/ops/adaptive_avg_pool3d.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+class AdaptiveAvgPool3D {
+public:
+    using schema = void (*)(Tensor, Tensor);
+    static void execute(Tensor y, Tensor x);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor adaptive_avg_pool3d(Tensor x, std::vector<size_t> output_size);
+void adaptive_avg_pool3d_(Tensor y, Tensor x);
+} // namespace infinicore::op

include/infinicore/ops/addr.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+class Addr {
+public:
+    using schema = void (*)(Tensor, Tensor, Tensor, Tensor, float, float);
+    static void execute(Tensor out, Tensor input, Tensor vec1, Tensor vec2, float beta = 1.0f, float alpha = 1.0f);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor addr(Tensor input, Tensor vec1, Tensor vec2, float beta = 1.0f, float alpha = 1.0f);
+void addr_(Tensor out, Tensor input, Tensor vec1, Tensor vec2, float beta = 1.0f, float alpha = 1.0f);
+} // namespace infinicore::op

include/infinicore/ops/argwhere.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+class Argwhere {
+public:
+    using schema = void (*)(void **, size_t *, Tensor);
+    static void execute(void **, size_t *count, Tensor x);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+Tensor argwhere(Tensor x);
+} // namespace infinicore::op

include/infinicore/ops/asin.hpp

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

include/infinicore/ops/fmin.hpp

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

include/infiniop.h

@@ -2,11 +2,14 @@
 #define __INFINIOP_API_H__
 
 #include "infiniop/handle.h"
+#include "infiniop/ops/adaptive_avg_pool3d.h"
 #include "infiniop/ops/adaptive_max_pool1d.h"
 #include "infiniop/ops/add.h"
 #include "infiniop/ops/add_rms_norm.h"
 #include "infiniop/ops/addcmul.h"
+#include "infiniop/ops/addr.h"
 #include "infiniop/ops/all.h"
+#include "infiniop/ops/asin.h"
 #include "infiniop/ops/asinh.h"
 #include "infiniop/ops/atanh.h"
 #include "infiniop/ops/attention.h"
@@ -19,11 +22,12 @@
 #include "infiniop/ops/cross_entropy.h"
 #include "infiniop/ops/dequant/per_tensor_dequant_int8.h"
 #include "infiniop/ops/dequantize_awq.h"
+#include "infiniop/ops/dequantize_gptq.h"
 #include "infiniop/ops/embedding.h"
 #include "infiniop/ops/equal.h"
 #include "infiniop/ops/flash_attention.h"
+#include "infiniop/ops/fmin.h"
 #include "infiniop/ops/fmod.h"
-#include "infiniop/ops/dequantize_gptq.h"
 #include "infiniop/ops/gelu.h"
 #include "infiniop/ops/gemm.h"
 #include "infiniop/ops/hardswish.h"

include/infiniop/ops/adaptive_avg_pool3d.h

@@ -0,0 +1,30 @@
+#ifndef INFINIOP_ADAPTIVE_AVG_POOL3D_H_
+#define INFINIOP_ADAPTIVE_AVG_POOL3D_H_
+
+#include "../operator_descriptor.h"
+#include <cstddef>
+
+typedef struct InfiniopDescriptor *infiniopAdaptiveAvgPool3DDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateAdaptiveAvgPool3DDescriptor(
+    infiniopHandle_t handle,
+    infiniopAdaptiveAvgPool3DDescriptor_t *desc_ptr,
+    infiniopTensorDescriptor_t y,
+    infiniopTensorDescriptor_t x,
+    size_t *output_size);
+
+__INFINI_C __export infiniStatus_t infiniopGetAdaptiveAvgPool3DWorkspaceSize(
+    infiniopAdaptiveAvgPool3DDescriptor_t desc,
+    size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopAdaptiveAvgPool3D(
+    infiniopAdaptiveAvgPool3DDescriptor_t desc,
+    void *workspace,
+    size_t workspace_size,
+    void *y,
+    const void *x,
+    void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyAdaptiveAvgPool3DDescriptor(infiniopAdaptiveAvgPool3DDescriptor_t desc);
+
+#endif

include/infiniop/ops/addr.h

@@ -0,0 +1,30 @@
+#ifndef __INFINIOP_ADDR_API_H__
+#define __INFINIOP_ADDR_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopAddrDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateAddrDescriptor(infiniopHandle_t handle,
+                                                                infiniopAddrDescriptor_t *desc_ptr,
+                                                                infiniopTensorDescriptor_t out,
+                                                                infiniopTensorDescriptor_t input,
+                                                                infiniopTensorDescriptor_t vec1,
+                                                                infiniopTensorDescriptor_t vec2,
+                                                                float beta,
+                                                                float alpha);
+
+__INFINI_C __export infiniStatus_t infiniopGetAddrWorkspaceSize(infiniopAddrDescriptor_t desc, size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopAddr(infiniopAddrDescriptor_t desc,
+                                                void *workspace,
+                                                size_t workspace_size,
+                                                void *out,
+                                                const void *input,
+                                                const void *vec1,
+                                                const void *vec2,
+                                                void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyAddrDescriptor(infiniopAddrDescriptor_t desc);
+
+#endif

include/infiniop/ops/argwhere.h

@@ -0,0 +1,29 @@
+#ifndef __INFINIOP_ARGWHERE_API_H__
+#define __INFINIOP_ARGWHERE_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopArgwhereDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateArgwhereDescriptor(
+    infiniopHandle_t handle,
+    infiniopArgwhereDescriptor_t *desc_ptr,
+    infiniopTensorDescriptor_t input_desc);
+
+__INFINI_C __export infiniStatus_t infiniopGetArgwhereWorkspaceSize(
+    infiniopArgwhereDescriptor_t desc,
+    size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopArgwhere(
+    infiniopArgwhereDescriptor_t desc,
+    void *workspace,
+    size_t workspace_size,
+    void **output,
+    size_t *count,
+    const void *input,
+    void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyArgwhereDescriptor(
+    infiniopArgwhereDescriptor_t desc);
+
+#endif // __INFINIOP_ARGWHERE_API_H__

include/infiniop/ops/asin.h

@@ -0,0 +1,24 @@
+#ifndef __INFINIOP_ASIN_API_H__
+#define __INFINIOP_ASIN_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopAsinDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateAsinDescriptor(infiniopHandle_t handle,
+                                                                infiniopAsinDescriptor_t *desc_ptr,
+                                                                infiniopTensorDescriptor_t output,
+                                                                infiniopTensorDescriptor_t input);
+
+__INFINI_C __export infiniStatus_t infiniopGetAsinWorkspaceSize(infiniopAsinDescriptor_t desc, size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopAsin(infiniopAsinDescriptor_t desc,
+                                                void *workspace,
+                                                size_t workspace_size,
+                                                void *output,
+                                                const void *input,
+                                                void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyAsinDescriptor(infiniopAsinDescriptor_t desc);
+
+#endif

include/infiniop/ops/fmin.h

@@ -0,0 +1,26 @@
+#ifndef __INFINIOP_FMIN_H__
+#define __INFINIOP_FMIN_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopFminDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateFminDescriptor(infiniopHandle_t handle,
+                                                                infiniopFminDescriptor_t *desc_ptr,
+                                                                infiniopTensorDescriptor_t c,
+                                                                infiniopTensorDescriptor_t a,
+                                                                infiniopTensorDescriptor_t b);
+
+__INFINI_C __export infiniStatus_t infiniopGetFminWorkspaceSize(infiniopFminDescriptor_t desc, size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopFmin(infiniopFminDescriptor_t desc,
+                                                void *workspace,
+                                                size_t workspace_size,
+                                                void *c,
+                                                const void *a,
+                                                const void *b,
+                                                void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyFminDescriptor(infiniopFminDescriptor_t desc);
+
+#endif

python/infinicore/__init__.py

@@ -50,7 +50,10 @@
 from infinicore.ops.add import add
 from infinicore.ops.add_rms_norm import add_rms_norm
 from infinicore.ops.addcmul import addcmul
+from infinicore.ops.addr import addr
 from infinicore.ops.all import all
+from infinicore.ops.argwhere import argwhere
+from infinicore.ops.asin import asin
 from infinicore.ops.asinh import asinh
 from infinicore.ops.atanh import atanh
 from infinicore.ops.attention import attention
@@ -62,6 +65,7 @@
 from infinicore.ops.cdist import cdist
 from infinicore.ops.cross_entropy import cross_entropy
 from infinicore.ops.equal import equal
+from infinicore.ops.fmin import fmin
 from infinicore.ops.fmod import fmod
 from infinicore.ops.kv_caching import kv_caching
 from infinicore.ops.matmul import matmul
@@ -143,8 +147,11 @@
     "cdist",
     "reciprocal",
     "add",
+    "addr",
     "add_rms_norm",
     "add_rms_norm_",
+    "argwhere",
+    "asin",
     "attention",
     "kv_caching",
     "asinh",
@@ -167,6 +174,7 @@
     "from_torch",
     "mha_kvcache",
     "mha_varlen",
+    "fmin",
     "paged_caching",
     "paged_attention",
     "paged_attention_prefill",

python/infinicore/nn/functional/__init__.py

@@ -1,3 +1,4 @@
+from .adaptive_avg_pool3d import adaptive_avg_pool3d
 from .adaptive_max_pool1d import adaptive_max_pool1d
 from .avg_pool1d import avg_pool1d
 from .binary_cross_entropy_with_logits import binary_cross_entropy_with_logits
@@ -33,4 +34,5 @@
     "swiglu",
     "linear_w8a8i8",
     "silu_and_mul",
+    "adaptive_avg_pool3d",
 ]

python/infinicore/nn/functional/adaptive_avg_pool3d.py

@@ -0,0 +1,17 @@
+from typing import List
+
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+
+def adaptive_avg_pool3d(x: Tensor, output_size: List[int] = {1, 1, 1}) -> Tensor:
+    r"""Applies a 3D adaptive average pooling over an input signal composed of several input planes.
+
+    Args:
+        x (Tensor): The input tensor of shape (N, C, D, H, W)
+        output_size (List[int]): The target output size of the form (d, h, w)
+
+    Returns:
+        Tensor: The pooled output tensor
+    """
+    return Tensor(_infinicore.adaptive_avg_pool3d(x._underlying, output_size))

python/infinicore/ops/addr.py

@@ -0,0 +1,28 @@
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+
+def addr(
+    input: Tensor,
+    vec1: Tensor,
+    vec2: Tensor,
+    beta: float = 1.0,
+    alpha: float = 1.0,
+    out=None,
+) -> Tensor:
+    if out is None:
+        return Tensor(
+            _infinicore.addr(
+                input._underlying, vec1._underlying, vec2._underlying, beta, alpha
+            )
+        )
+
+    _infinicore.addr_(
+        out._underlying,
+        input._underlying,
+        vec1._underlying,
+        vec2._underlying,
+        beta,
+        alpha,
+    )
+    return out

python/infinicore/ops/argwhere.py

@@ -0,0 +1,6 @@
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+
+def argwhere(x: Tensor) -> Tensor:
+    return Tensor(_infinicore.argwhere(x._underlying))

python/infinicore/ops/asin.py

@@ -0,0 +1,11 @@
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+
+def asin(input: Tensor, *, out=None):
+    """Arcsin activation function."""
+    if out is None:
+        return Tensor(_infinicore.asin(input._underlying))
+
+    _infinicore.asin_(out._underlying, input._underlying)
+    return out