[2025秋季][T1-1-50]zili2004

include/infinicore/ops/logcumsumexp.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class LogCumSumExp {
+public:
+    using schema = void (*)(Tensor, Tensor, int, bool, bool);
+
+    static void execute(Tensor y, Tensor x, int axis, bool exclusive, bool reverse);
+
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor logcumsumexp(Tensor x, int axis, bool exclusive = false, bool reverse = false);
+
+void logcumsumexp_(Tensor y, Tensor x, int axis, bool exclusive = false, bool reverse = false);
+
+} // namespace infinicore::op

include/infinicore/ops/logical_and.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class LogicalAnd {
+public:
+    // LogicalAnd 是二元操作，schema 通常定义为 (Output, Input1, Input2)
+    using schema = void (*)(Tensor, Tensor, Tensor);
+
+    static void execute(Tensor output, Tensor input1, Tensor input2);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor logical_and(Tensor input1, Tensor input2);
+void logical_and_(Tensor output, Tensor input1, Tensor input2);
+
+} // namespace infinicore::op

include/infinicore/ops/logical_not.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class LogicalNot {
+public:
+    // LogicalNot 是一元操作，schema 定义为 (Output, Input)
+    using schema = void (*)(Tensor, Tensor);
+
+    static void execute(Tensor output, Tensor input);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+// 构造新 Tensor 返回结果
+Tensor logical_not(Tensor input);
+
+// 将结果写入指定的 output Tensor
+void logical_not_(Tensor output, Tensor input);
+
+} // namespace infinicore::op

include/infinicore/ops/unfold.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <vector>
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class Unfold {
+public:
+    // schema: output, input, kernel_sizes, dilations, paddings, strides
+    using schema = void (*)(Tensor, Tensor, const std::vector<int64_t>&, const std::vector<int64_t>&, const std::vector<int64_t>&, const std::vector<int64_t>&);
+
+    static void execute(Tensor output, Tensor input, 
+                        const std::vector<int64_t>& kernel_sizes, 
+                        const std::vector<int64_t>& dilations, 
+                        const std::vector<int64_t>& paddings, 
+                        const std::vector<int64_t>& strides);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+// Functional API
+Tensor unfold(Tensor input, 
+              std::vector<int64_t> kernel_sizes, 
+              std::vector<int64_t> dilations, 
+              std::vector<int64_t> paddings, 
+              std::vector<int64_t> strides);
+
+void unfold_(Tensor output, Tensor input, 
+             std::vector<int64_t> kernel_sizes, 
+             std::vector<int64_t> dilations, 
+             std::vector<int64_t> paddings, 
+             std::vector<int64_t> strides);
+
+} // namespace infinicore::op

include/infinicore/ops/vander.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class Vander {
+public:
+    // schema: output, input, N, increasing
+    using schema = void (*)(Tensor, Tensor, int64_t, bool);
+
+    static void execute(Tensor output, Tensor input, int64_t N, bool increasing);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+// N defaults to 0 (implying N = input.size(0), i.e., a square matrix)
+Tensor vander(Tensor input, int64_t N = 0, bool increasing = false);
+void vander_(Tensor output, Tensor input, int64_t N, bool increasing);
+
+} // namespace infinicore::op

include/infiniop.h

@@ -34,6 +34,9 @@
 #include "infiniop/ops/topkrouter.h"
 #include "infiniop/ops/topksoftmax.h"
 #include "infiniop/ops/zeros.h"
+#include "infiniop/ops/unfold.h"
+#include "infiniop/ops/vander.h"
+#include "infiniop/ops/logcumsumexp.h"
 #include "infiniop/tensor_descriptor.h"
 
 #endif // __INFINIOP_API_H__

include/infiniop/ops/logcumsumexp.h

@@ -0,0 +1,30 @@
+#ifndef __INFINIOP_LOGCUMSUMEXP_API_H__
+#define __INFINIOP_LOGCUMSUMEXP_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopLogCumSumExpDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateLogCumSumExpDescriptor(infiniopHandle_t handle,
+                                                                infiniopLogCumSumExpDescriptor_t *desc_ptr,
+                                                                infiniopTensorDescriptor_t y,
+                                                                infiniopTensorDescriptor_t x,
+                                                                int axis,
+                                                                int exclusive,
+                                                                int reverse);
+
+/* 获取执行 LogCumSumExp 所需的临时空间大小 */
+__C __export infiniStatus_t infiniopGetLogCumSumExpWorkspaceSize(infiniopLogCumSumExpDescriptor_t desc, 
+                                                                 size_t *size);
+
+__C __export infiniStatus_t infiniopLogCumSumExp(infiniopLogCumSumExpDescriptor_t desc,
+                                                void *workspace,
+                                                size_t workspace_size,
+                                                void *y,
+                                                const void *x,
+                                                void *stream);
+
+/* 销毁描述符 */
+__C __export infiniStatus_t infiniopDestroyLogCumSumExpDescriptor(infiniopLogCumSumExpDescriptor_t desc);
+
+#endif

include/infiniop/ops/unfold.h

@@ -0,0 +1,28 @@
+#ifndef __INFINIOP_UNFOLD_API_H__
+#define __INFINIOP_UNFOLD_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopUnfoldDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateUnfoldDescriptor(infiniopHandle_t handle,
+                                                           infiniopUnfoldDescriptor_t *desc_ptr,
+                                                           infiniopTensorDescriptor_t output,
+                                                           infiniopTensorDescriptor_t input,
+                                                           const int *kernel_sizes,
+                                                           const int *strides,
+                                                           const int *paddings,
+                                                           const int *dilations);
+
+// 获取 Unfold 工作区大小
+__C __export infiniStatus_t infiniopGetUnfoldWorkspaceSize(infiniopUnfoldDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopUnfold(infiniopUnfoldDescriptor_t desc,
+                                           void *workspace,
+                                           size_t workspace_size,
+                                           void *output,
+                                           const void *input,
+                                           void *stream);
+__C __export infiniStatus_t infiniopDestroyUnfoldDescriptor(infiniopUnfoldDescriptor_t desc);
+
+#endif // __INFINIOP_UNFOLD_API_H__

include/infiniop/ops/vander.h

@@ -0,0 +1,25 @@
+#ifndef __INFINIOP_VANDER_API_H__
+#define __INFINIOP_VANDER_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopVanderDescriptor_t;
+__C __export infiniStatus_t infiniopCreateVanderDescriptor(infiniopHandle_t handle,
+                                                           infiniopVanderDescriptor_t *desc_ptr,
+                                                           infiniopTensorDescriptor_t output,
+                                                           infiniopTensorDescriptor_t input,
+                                                           int N,
+                                                           int increasing);
+
+__C __export infiniStatus_t infiniopGetVanderWorkspaceSize(infiniopVanderDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopVander(infiniopVanderDescriptor_t desc,
+                                           void *workspace,
+                                           size_t workspace_size,
+                                           void *output,
+                                           const void *input,
+                                           void *stream);
+
+__C __export infiniStatus_t infiniopDestroyVanderDescriptor(infiniopVanderDescriptor_t desc);
+
+#endif // __INFINIOP_VANDER_API_H__

python/infinicore/__init__.py

@@ -51,6 +51,10 @@
 from infinicore.ops.rearrange import rearrange
 from infinicore.ops.squeeze import squeeze
 from infinicore.ops.unsqueeze import unsqueeze
+from infinicore.ops.logcumsumexp import logcumsumexp
+from infinicore.ops.logical_and import logical_and
+from infinicore.ops.logical_not import logical_not
+from infinicore.ops.vander import vander
 from infinicore.tensor import (
     Tensor,
     empty,
@@ -121,6 +125,10 @@
     "from_list",
     "from_numpy",
     "from_torch",
+    "logcumsumexp",
+    "logical_not",
+    "logical_and",
+    "vander",
     "paged_caching",
     "paged_attention",
     "paged_attention_prefill",

python/infinicore/nn/functional/__init__.py

@@ -6,6 +6,7 @@
 from .rope import RopeAlgo, rope
 from .silu import silu
 from .swiglu import swiglu
+from .unfold import unfold
 
 __all__ = [
     "causal_softmax",
@@ -16,5 +17,6 @@
     "linear",
     "embedding",
     "rope",
+    "unfold",
     "RopeAlgo",
 ]

python/infinicore/nn/functional/unfold.py

@@ -0,0 +1,58 @@
+from typing import Optional, Union, Tuple, List
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+def unfold(
+    input: Tensor, 
+    kernel_size: Union[int, Tuple[int, ...], List[int]], 
+    dilation: Union[int, Tuple[int, ...], List[int]] = 1, 
+    padding: Union[int, Tuple[int, ...], List[int]] = 0, 
+    stride: Union[int, Tuple[int, ...], List[int]] = 1, 
+    *, 
+    out: Optional[Tensor] = None
+) -> Tensor:
+    r"""Extracts sliding local blocks from a batched input tensor.
+
+    Also known as im2col. The output tensor contains the flattened blocks.
+
+    Args:
+        input (Tensor): The input tensor.
+        kernel_size (int or tuple): The size of the sliding blocks.
+        dilation (int or tuple, optional): The parameter that controls the stride of elements within the neighborhood. Default: 1.
+        padding (int or tuple, optional): Implicit zero padding to be added on both sides of input. Default: 0.
+        stride (int or tuple, optional): The stride of the sliding blocks. Default: 1.
+        out (Tensor, optional): The output tensor.
+    """
+
+    if not input.is_contiguous():
+        input = input.contiguous()
+
+    # Helper to ensure parameters are iterable (assuming 2D spatial dims for single int)
+    def _pair(x):
+        return (x, x) if isinstance(x, int) else x
+
+    k_val = _pair(kernel_size)
+    d_val = _pair(dilation)
+    p_val = _pair(padding)
+    s_val = _pair(stride)
+
+    if out is not None:
+        _infinicore.unfold_(
+            out._underlying,
+            input._underlying,
+            k_val,
+            d_val,
+            p_val,
+            s_val
+        )
+        return out
+
+    return Tensor(
+        _infinicore.unfold(
+            input._underlying,
+            k_val,
+            d_val,
+            p_val,
+            s_val
+        )
+    )

python/infinicore/ops/logcumsumexp.py

@@ -0,0 +1,23 @@
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+def logcumsumexp(input, dim, exclusive=False, reverse=False, *, out=None):
+    if out is None:
+        # 调用 C++ 绑定的非原地操作，返回新创建的 _underlying 句柄
+        return Tensor(_infinicore.logcumsumexp(
+            input._underlying, 
+            dim, 
+            exclusive, 
+            reverse
+        ))
+
+    # 调用 C++ 绑定的原地/指定输出操作
+    _infinicore.logcumsumexp_(
+        out._underlying, 
+        input._underlying, 
+        dim, 
+        exclusive, 
+        reverse
+    )
+
+    return out

python/infinicore/ops/logical_and.py

@@ -0,0 +1,14 @@
+import infinicore
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+def logical_and(input: Tensor, other: Tensor, *, out=None) -> Tensor:
+    r"""Computes the element-wise logical AND of the given input tensors."""
+    if infinicore.use_ntops and input.device.type in ("cuda", "musa"):
+        return infinicore.ntops.torch.logical_and(input, other, out=out)
+
+    if out is None:
+        return Tensor(_infinicore.logical_and(input._underlying, other._underlying))
+
+    _infinicore.logical_and_(out._underlying, input._underlying, other._underlying)
+    return out

python/infinicore/ops/logical_not.py

@@ -0,0 +1,17 @@
+import infinicore
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+def logical_not(input: Tensor, *, out=None) -> Tensor:
+    r"""Computes the element-wise logical NOT of the given input tensors."""
+    # 1. 如果启用了 ntops 且设备支持，调用 ntops 实现
+    if infinicore.use_ntops and input.device.type in ("cuda", "musa"):
+        return infinicore.ntops.torch.logical_not(input, out=out)
+
+    # 2. 如果没有提供 out，创建一个新的 Tensor 并返回
+    if out is None:
+        return Tensor(_infinicore.logical_not(input._underlying))
+
+    # 3. 如果提供了 out，进行原地操作 (In-place operation)
+    _infinicore.logical_not_(out._underlying, input._underlying)
+    return out