[2025秋季][T1-1-9] littleotherut

.gitignore

@@ -31,4 +31,4 @@ cache/
 # Compressed
 *.gz
 *.zip
-*.tar
+*.tar

include/infinicore/ops.hpp

@@ -1,8 +1,13 @@
 #pragma once
 
+#include "ops/adaptive_max_pool1d.hpp"
 #include "ops/add.hpp"
+#include "ops/asinh.hpp"
 #include "ops/attention.hpp"
+#include "ops/baddbmm.hpp"
+#include "ops/bilinear.hpp"
 #include "ops/causal_softmax.hpp"
+#include "ops/fmod.hpp"
 #include "ops/matmul.hpp"
 #include "ops/ones.hpp"
 #include "ops/rearrange.hpp"

include/infinicore/ops/adaptive_max_pool1d.hpp

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

include/infinicore/ops/asinh.hpp

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

include/infinicore/ops/baddbmm.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+#include <optional>
+
+namespace infinicore::op {
+
+Tensor baddbmm(Tensor input, Tensor batch1, Tensor batch2,
+               float beta = 1.0f,
+               float alpha = 1.0f);
+void baddbmm_(Tensor out, Tensor input, Tensor batch1, Tensor batch2,
+              float beta = 1.0f,
+              float alpha = 1.0f);
+} // namespace infinicore::op

include/infinicore/ops/bilinear.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+#include <optional>
+
+namespace infinicore::op {
+
+Tensor bilinear(Tensor x1, Tensor x2, Tensor weight, std::optional<Tensor> bias);
+void bilinear_(Tensor out, Tensor x1, Tensor x2, Tensor weight, std::optional<Tensor> bias);
+
+} // namespace infinicore::op

include/infinicore/ops/fmod.hpp

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

include/infiniop.h

@@ -2,12 +2,15 @@
 #define __INFINIOP_API_H__
 
 #include "infiniop/handle.h"
+#include "infiniop/ops/adaptive_max_pool1d.h"
 #include "infiniop/ops/add.h"
+#include "infiniop/ops/asinh.h"
 #include "infiniop/ops/attention.h"
 #include "infiniop/ops/causal_softmax.h"
 #include "infiniop/ops/clip.h"
 #include "infiniop/ops/conv.h"
 #include "infiniop/ops/dequantize_awq.h"
+#include "infiniop/ops/fmod.h"
 #include "infiniop/ops/gelu.h"
 #include "infiniop/ops/gemm.h"
 #include "infiniop/ops/layer_norm.h"

include/infiniop/ops/adaptive_max_pool1d.h

@@ -0,0 +1,22 @@
+#ifndef __INFINIOP_ADAPTIVE_MAX_POOL1D_H__
+#define __INFINIOP_ADAPTIVE_MAX_POOL1D_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopAdaptiveMaxPool1dDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateAdaptiveMaxPool1dDescriptor(
+    infiniopHandle_t handle,
+    infiniopAdaptiveMaxPool1dDescriptor_t *desc,
+    infiniopTensorDescriptor_t y_desc,
+    infiniopTensorDescriptor_t x_desc,
+    size_t output_size);
+
+__C __export infiniStatus_t infiniopGetAdaptiveMaxPool1dWorkspaceSize(infiniopAdaptiveMaxPool1dDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopAdaptiveMaxPool1d(infiniopAdaptiveMaxPool1dDescriptor_t desc, void *workspace, size_t workspace_size,
+                                                      void *y, const void *x, void *stream);
+
+__C __export infiniStatus_t infiniopDestroyAdaptiveMaxPool1dDescriptor(infiniopAdaptiveMaxPool1dDescriptor_t desc);
+
+#endif

include/infiniop/ops/asinh.h

@@ -0,0 +1,24 @@
+#ifndef __INFINIOP_ASINH_API_H_
+#define __INFINIOP_ASINH_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopAsinhDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateAsinhDescriptor(infiniopHandle_t handle,
+                                                          infiniopAsinhDescriptor_t *desc_ptr,
+                                                          infiniopTensorDescriptor_t y,
+                                                          infiniopTensorDescriptor_t x);
+
+__C __export infiniStatus_t infiniopGetAsinhWorkspaceSize(infiniopAsinhDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopAsinh(infiniopAsinhDescriptor_t desc,
+                                          void *workspace,
+                                          size_t workspace_size,
+                                          void *y,
+                                          const void *x,
+                                          void *stream);
+
+__C __export infiniStatus_t infiniopDestroyAsinhDescriptor(infiniopAsinhDescriptor_t desc);
+
+#endif

include/infiniop/ops/fmod.h

@@ -0,0 +1,26 @@
+#ifndef __INFINIOP_FMOD_API_H_
+#define __INFINIOP_FMOD_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopFmodDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateFmodDescriptor(infiniopHandle_t handle,
+                                                         infiniopFmodDescriptor_t *desc_ptr,
+                                                         infiniopTensorDescriptor_t c,
+                                                         infiniopTensorDescriptor_t a,
+                                                         infiniopTensorDescriptor_t b);
+
+__C __export infiniStatus_t infiniopGetFmodWorkspaceSize(infiniopFmodDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopFmod(infiniopFmodDescriptor_t desc,
+                                         void *workspace,
+                                         size_t workspace_size,
+                                         void *c,
+                                         const void *a,
+                                         const void *b,
+                                         void *stream);
+
+__C __export infiniStatus_t infiniopDestroyFmodDescriptor(infiniopFmodDescriptor_t desc);
+
+#endif

python/infinicore/__init__.py

@@ -41,10 +41,14 @@
 )
 from infinicore.ops.add import add
 from infinicore.ops.attention import attention
+from infinicore.ops.asinh import asinh
 from infinicore.ops.matmul import matmul
 from infinicore.ops.mul import mul
 from infinicore.ops.narrow import narrow
 from infinicore.ops.rearrange import rearrange
+from infinicore.ops.baddbmm import baddbmm
+from infinicore.ops.bilinear import bilinear
+from infinicore.ops.fmod import fmod
 from infinicore.tensor import (
     Tensor,
     empty,
@@ -101,6 +105,10 @@
     # Operations.
     "add",
     "attention",
+    "asinh",
+    "baddbmm",
+    "bilinear",
+    "fmod",
     "matmul",
     "mul",
     "narrow",

python/infinicore/nn/functional/__init__.py

@@ -1,3 +1,4 @@
+from .adaptive_max_pool1d import adaptive_max_pool1d
 from .causal_softmax import causal_softmax
 from .embedding import embedding
 from .linear import linear
@@ -8,6 +9,7 @@
 from .swiglu import swiglu
 
 __all__ = [
+    "adaptive_max_pool1d",
     "causal_softmax",
     "random_sample",
     "rms_norm",

python/infinicore/nn/functional/adaptive_max_pool1d.py

@@ -0,0 +1,39 @@
+from typing import List
+
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+
+def adaptive_max_pool1d(
+    input: Tensor,
+    output_size: int,
+    *,
+    out=None,
+) -> Tensor:
+    r"""Applies a 1D adaptive max pooling over an input signal composed of
+    several input planes.
+
+    The output size is H_out. The algorithm used is fairly simple:
+
+    .. math::
+        \text{start} = \left\lfloor \frac{i \cdot L_{in}}{L_{out}} \right\rfloor
+
+        \text{end} = \left\lceil \frac{(i + 1) \cdot L_{in}}{L_{out}} \right\rceil
+
+    where :math:`L_{in}` is the size of the input dimension, and :math:`L_{out}` is the size of the output dimension.
+
+    Args:
+        input (Tensor): Input tensor of shape (N, C, L_in)
+        output_size (int): The target output size (L_out)
+        out (Tensor, optional): Output tensor.
+
+    Returns:
+        Tensor: The result of the adaptive max pooling operation.
+    """
+
+    if out is None:
+        return Tensor(_infinicore.adaptive_max_pool1d(input._underlying, output_size))
+
+    _infinicore.adaptive_max_pool1d_(out._underlying, input._underlying, output_size)
+
+    return out

python/infinicore/ops/asinh.py

@@ -0,0 +1,11 @@
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+
+def asinh(input, *, out=None):
+    if out is None:
+        return Tensor(_infinicore.asinh(input._underlying))
+
+    _infinicore.asinh_(out._underlying, input._underlying)
+
+    return out

python/infinicore/ops/baddbmm.py

@@ -0,0 +1,25 @@
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+
+def baddbmm(input, batch1, batch2, *, beta=1.0, alpha=1.0, out=None):
+    if out is None:
+        return Tensor(
+            _infinicore.baddbmm(
+                input._underlying,
+                batch1._underlying,
+                batch2._underlying,
+                float(beta),
+                float(alpha),
+            )
+        )
+    _infinicore.baddbmm_(
+        out._underlying,
+        input._underlying,
+        batch1._underlying,
+        batch2._underlying,
+        float(beta),
+        float(alpha),
+    )
+
+    return out

python/infinicore/ops/bilinear.py

@@ -0,0 +1,23 @@
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+
+def bilinear(input1, input2, weight, bias=None, *, out=None):
+    if out is None:
+        return Tensor(
+            _infinicore.bilinear(
+                input1._underlying,
+                input2._underlying,
+                weight._underlying,
+                bias._underlying if bias is not None else None,
+            )
+        )
+    _infinicore.bilinear_(
+        out._underlying,
+        input1._underlying,
+        input2._underlying,
+        weight._underlying,
+        bias._underlying if bias is not None else None,
+    )
+
+    return out

python/infinicore/ops/fmod.py

@@ -0,0 +1,11 @@
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+
+def fmod(input, other, *, out=None):
+    if out is None:
+        return Tensor(_infinicore.fmod(input._underlying, other._underlying))
+
+    _infinicore.fmod_(out._underlying, input._underlying, other._underlying)
+
+    return out

src/infinicore/ops/adaptive_max_pool1d/adaptive_max_pool1d.cc

@@ -0,0 +1,30 @@
+#include "infinicore/ops/adaptive_max_pool1d.hpp"
+
+#include "../../utils.hpp"
+
+namespace infinicore::op {
+
+common::OpDispatcher<AdaptiveMaxPool1d::schema> &AdaptiveMaxPool1d::dispatcher() {
+    static common::OpDispatcher<AdaptiveMaxPool1d::schema> dispatcher_;
+    return dispatcher_;
+}
+
+void AdaptiveMaxPool1d::execute(Tensor y, Tensor x, size_t output_size) {
+    INFINICORE_ASSERT_TENSORS_SAME_DEVICE(y, x);
+    infinicore::context::setDevice(y->device());
+    dispatcher().lookup(y->device().getType())(y, x, output_size);
+}
+
+Tensor adaptive_max_pool1d(Tensor x, size_t output_size) {
+    infinicore::Shape y_shape = x->shape();
+    y_shape.back() = output_size;
+    auto y = Tensor::empty(y_shape, x->dtype(), x->device());
+    adaptive_max_pool1d_(y, x, output_size);
+    return y;
+}
+
+void adaptive_max_pool1d_(Tensor y, Tensor x, size_t output_size) {
+    AdaptiveMaxPool1d::execute(y, x, output_size);
+}
+
+} // namespace infinicore::op