Merge pull request #1074 from InfiniTensor/RevertT_1-1-15

Revert "Merge pull request #1069 from InfiniTensor/issue/1031_T1_1_15"

include/infinicore/common/hash.hpp

@@ -16,11 +16,6 @@ hash_combine(size_t &seed, const T &value) {
 
 // Specialization for Tensor
 inline void hash_combine(size_t &seed, Tensor tensor) {
-    if (!tensor) {
-        hash_combine(seed, static_cast<size_t>(0));
-        return;
-    }
-
     hash_combine(seed, static_cast<size_t>(tensor->dtype()));
     for (Size shape : tensor->shape()) {
         hash_combine(seed, shape);

include/infinicore/ops.hpp

@@ -2,13 +2,9 @@
 
 #include "ops/add.hpp"
 #include "ops/add_rms_norm.hpp"
-#include "ops/addcmul.hpp"
-#include "ops/atanh.hpp"
 #include "ops/attention.hpp"
 #include "ops/avg_pool1d.hpp"
-#include "ops/binary_cross_entropy_with_logits.hpp"
 #include "ops/causal_softmax.hpp"
-#include "ops/cdist.hpp"
 #include "ops/cross_entropy.hpp"
 #include "ops/embedding.hpp"
 #include "ops/flash_attention.hpp"
@@ -22,7 +18,6 @@
 #include "ops/paged_caching.hpp"
 #include "ops/random_sample.hpp"
 #include "ops/rearrange.hpp"
-#include "ops/reciprocal.hpp"
 #include "ops/rms_norm.hpp"
 #include "ops/rope.hpp"
 #include "ops/silu.hpp"

include/infinicore/ops/addcmul.hpp

-#pragma once
-
-#include "../device.hpp"
-#include "common/op.hpp"
-
-namespace infinicore::op {
-
-class Addcmul {
-public:
-    // schema: out, input, t1, t2, value
-    using schema = void (*)(Tensor, Tensor, Tensor, Tensor, float);
-    static void execute(Tensor out, Tensor input, Tensor t1, Tensor t2, float value);
-    static common::OpDispatcher<schema> &dispatcher();
-};
-Tensor addcmul(Tensor input, Tensor t1, Tensor t2, float value);
-void addcmul_(Tensor out, Tensor input, Tensor t1, Tensor t2, float value);
-} // namespace infinicore::op

include/infinicore/ops/atanh.hpp

-#pragma once
-
-#include "../device.hpp"
-#include "common/op.hpp"
-
-namespace infinicore::op {
-
-class Atanh {
-public:
-    // schema 定义为：void(输出 Tensor, 输入 Tensor)
-    using schema = void (*)(Tensor, Tensor);
-
-    // 执行函数
-    static void execute(Tensor y, Tensor a);
-
-    // 获取算子分发器，用于多后端（CPU/CUDA 等）匹配
-    static common::OpDispatcher<schema> &dispatcher();
-};
-
-/**
- * @brief 计算输入 Tensor 的反双曲正切值 (out-of-place)
- * @param a 输入 Tensor
- * @return 包含结果的新 Tensor
- */
-Tensor atanh(Tensor a);
-
-/**
- * @brief 计算输入 Tensor 的反双曲正切值 (in-place / specified output)
- * @param y 输出 Tensor
- * @param a 输入 Tensor
- */
-void atanh_(Tensor y, Tensor a);
-
-} // namespace infinicore::op

include/infinicore/ops/binary_cross_entropy_with_logits.hpp

-#pragma once
-
-#include "../device.hpp"
-#include "common/op.hpp"
-#include <string>
-
-namespace infinicore::op {
-
-class BinaryCrossEntropyWithLogits {
-public:
-    /**
-     * @brief BCEWithLogits 算子的函数原型
-     * 参数顺序: out, logits, target, weight, pos_weight, reduction
-     */
-    using schema = void (*)(Tensor, Tensor, Tensor, Tensor, Tensor, std::string);
-
-    static void execute(Tensor out,
-                        Tensor logits,
-                        Tensor target,
-                        Tensor weight,
-                        Tensor pos_weight,
-                        std::string reduction);
-
-    static common::OpDispatcher<schema> &dispatcher();
-};
-
-/**
- * @brief 非原地操作接口 (Out-of-place)
- */
-Tensor binary_cross_entropy_with_logits(Tensor logits,
-                                        Tensor target,
-                                        Tensor weight = {},
-                                        Tensor pos_weight = {},
-                                        std::string reduction = "mean");
-
-/**
- * @brief 显式指定输出张量的接口
- */
-void binary_cross_entropy_with_logits_(Tensor out,
-                                       Tensor logits,
-                                       Tensor target,
-                                       Tensor weight,
-                                       Tensor pos_weight,
-                                       std::string reduction);
-
-} // namespace infinicore::op

include/infinicore/ops/cdist.hpp

-#pragma once
-
-#include "../device.hpp"
-#include "common/op.hpp"
-
-namespace infinicore::op {
-
-class Cdist {
-public:
-    /**
-     * @brief 成对距离计算算子 (Pairwise distance)
-     * schema: out (M, N), x1 (M, D), x2 (N, D), p (norm degree)
-     */
-    using schema = void (*)(Tensor, Tensor, Tensor, double);
-
-    static void execute(Tensor out, Tensor x1, Tensor x2, double p);
-
-    static common::OpDispatcher<schema> &dispatcher();
-};
-
-/**
- * @brief 非原地（Out-of-place）接口
- * @return 返回形状为 (M, N) 的新 Tensor
- */
-Tensor cdist(Tensor x1, Tensor x2, double p = 2.0);
-
-/**
- * @brief 显式指定输出接口
- */
-void cdist_(Tensor out, Tensor x1, Tensor x2, double p = 2.0);
-
-} // namespace infinicore::op

include/infinicore/ops/reciprocal.hpp

-#pragma once
-
-#include "../device.hpp"
-#include "common/op.hpp"
-
-namespace infinicore::op {
-class Reciprocal {
-public:
-    using schema = void (*)(Tensor, Tensor);
-    static void execute(Tensor y, Tensor x);
-    static common::OpDispatcher<schema> &dispatcher();
-};
-
-Tensor reciprocal(Tensor x);
-void reciprocal_(Tensor y, Tensor x);
-} // namespace infinicore::op

include/infiniop.h

@@ -4,25 +4,16 @@
 #include "infiniop/handle.h"
 #include "infiniop/ops/add.h"
 #include "infiniop/ops/add_rms_norm.h"
-#include "infiniop/ops/addcmul.h"
 #include "infiniop/ops/all.h"
-#include "infiniop/ops/atanh.h"
 #include "infiniop/ops/attention.h"
-#include "infiniop/ops/avg_pool1d.h"
-#include "infiniop/ops/binary_cross_entropy_with_logits.h"
 #include "infiniop/ops/causal_softmax.h"
-#include "infiniop/ops/cdist.h"
 #include "infiniop/ops/clip.h"
 #include "infiniop/ops/conv.h"
-#include "infiniop/ops/cross_entropy.h"
 #include "infiniop/ops/dequantize_awq.h"
 #include "infiniop/ops/embedding.h"
-#include "infiniop/ops/equal.h"
 #include "infiniop/ops/flash_attention.h"
 #include "infiniop/ops/gelu.h"
 #include "infiniop/ops/gemm.h"
-#include "infiniop/ops/hardswish.h"
-#include "infiniop/ops/hardtanh.h"
 #include "infiniop/ops/int8_gemm.h"
 #include "infiniop/ops/kv_caching.h"
 #include "infiniop/ops/layer_norm.h"
@@ -36,7 +27,6 @@
 #include "infiniop/ops/quant/per_channel_quant_int8.h"
 #include "infiniop/ops/random_sample.h"
 #include "infiniop/ops/rearrange.h"
-#include "infiniop/ops/reciprocal.h"
 #include "infiniop/ops/relu.h"
 #include "infiniop/ops/rms_norm.h"
 #include "infiniop/ops/rope.h"
@@ -57,4 +47,10 @@
 #include "infiniop/ops/zeros.h"
 #include "infiniop/tensor_descriptor.h"
 
+#include "infiniop/ops/cross_entropy.h"
+#include "infiniop/ops/hardswish.h"
+#include "infiniop/ops/avg_pool1d.h"
+#include "infiniop/ops/equal.h"
+#include "infiniop/ops/hardtanh.h"
+
 #endif // __INFINIOP_API_H__

include/infiniop/ops/addcmul.h

-#ifndef __INFINIOP_ADDCMUL_API_H__
-#define __INFINIOP_ADDCMUL_API_H__
-
-#include "../operator_descriptor.h"
-
-// 定义 addcmul 算子描述符类型
-typedef struct InfiniopDescriptor *infiniopAddcmulDescriptor_t;
-
-/**
- * @brief 创建 Addcmul 算子描述符
- * @param handle 算子句柄
- * @param desc_ptr 指向返回的描述符指针
- * @param out 输出张量描述符
- * @param input 加项张量描述符
- * @param tensor1 乘项张量1描述符
- * @param tensor2 乘项张量2描述符
- * @param value 乘积的标量系数
- */
-__INFINI_C __export infiniStatus_t infiniopCreateAddcmulDescriptor(infiniopHandle_t handle,
-                                                                   infiniopAddcmulDescriptor_t *desc_ptr,
-                                                                   infiniopTensorDescriptor_t out,
-                                                                   infiniopTensorDescriptor_t input,
-                                                                   infiniopTensorDescriptor_t tensor1,
-                                                                   infiniopTensorDescriptor_t tensor2,
-                                                                   float value);
-
-/**
- * @brief 获取 Addcmul 计算所需的临时空间大小
- */
-__INFINI_C __export infiniStatus_t infiniopGetAddcmulWorkspaceSize(infiniopAddcmulDescriptor_t desc, size_t *size);
-
-/**
- * @brief 执行 Addcmul 计算
- * @param desc 算子描述符
- * @param workspace 临时空间指针
- * @param workspace_size 临时空间大小
- * @param out 输出数据指针
- * @param input 加项数据指针
- * @param tensor1 乘项1数据指针
- * @param tensor2 乘项2数据指针
- * @param stream 计算流 (CUDA stream 等)
- */
-__INFINI_C __export infiniStatus_t infiniopAddcmul(infiniopAddcmulDescriptor_t desc,
-                                                   void *workspace,
-                                                   size_t workspace_size,
-                                                   void *out,
-                                                   const void *input,
-                                                   const void *tensor1,
-                                                   const void *tensor2,
-                                                   void *stream);
-
-/**
- * @brief 销毁 Addcmul 算子描述符
- */
-__INFINI_C __export infiniStatus_t infiniopDestroyAddcmulDescriptor(infiniopAddcmulDescriptor_t desc);
-
-#endif

include/infiniop/ops/atanh.h

-#ifndef __INFINIOP_Atanh_API_H__
-#define __INFINIOP_Atanh_API_H__
-
-#include "../operator_descriptor.h"
-
-typedef struct InfiniopDescriptor *infiniopAtanhDescriptor_t;
-
-__INFINI_C __export infiniStatus_t infiniopCreateAtanhDescriptor(infiniopHandle_t handle,
-                                                                 infiniopAtanhDescriptor_t *desc_ptr,
-                                                                 infiniopTensorDescriptor_t y,
-                                                                 infiniopTensorDescriptor_t a);
-
-__INFINI_C __export infiniStatus_t infiniopGetAtanhWorkspaceSize(infiniopAtanhDescriptor_t desc, size_t *size);
-
-__INFINI_C __export infiniStatus_t infiniopAtanh(infiniopAtanhDescriptor_t desc,
-                                                 void *workspace,
-                                                 size_t workspace_size,
-                                                 void *y,
-                                                 const void *a,
-                                                 void *stream);
-
-__INFINI_C __export infiniStatus_t infiniopDestroyAtanhDescriptor(infiniopAtanhDescriptor_t desc);
-
-#endif

include/infiniop/ops/binary_cross_entropy_with_logits.h

-#ifndef __INFINIOP_BINARY_CROSS_ENTROPY_WITH_LOGITS_API_H__
-#define __INFINIOP_BINARY_CROSS_ENTROPY_WITH_LOGITS_API_H__
-
-#include "../operator_descriptor.h"
-
-// 定义归约方式枚举
-typedef enum {
-    INFINIOP_REDUCTION_NONE = 0,
-    INFINIOP_REDUCTION_MEAN = 1,
-    INFINIOP_REDUCTION_SUM = 2
-} infiniopReduction_t;
-
-// 定义 BCEWithLogits 算子描述符类型
-typedef struct InfiniopDescriptor *infiniopBCEWithLogitsDescriptor_t;
-
-/**
- * @brief 创建 BCEWithLogits 算子描述符
- * @param handle 算子句柄
- * @param desc_ptr 指向返回的描述符指针
- * @param out 输出张量描述符 (none时与input同形状，mean/sum时为标量)
- * @param logits 输入 Logits 张量描述符
- * @param target 目标标签张量描述符
- * @param weight 样本权重描述符 (可选，不需要则传 NULL)
- * @param pos_weight 正样本权重描述符 (可选，不需要则传 NULL)
- * @param reduction 归约方式 (none, mean, sum)
- */
-__INFINI_C __export infiniStatus_t infiniopCreateBCEWithLogitsDescriptor(
-    infiniopHandle_t handle,
-    infiniopBCEWithLogitsDescriptor_t *desc_ptr,
-    infiniopTensorDescriptor_t out,
-    infiniopTensorDescriptor_t logits,
-    infiniopTensorDescriptor_t target,
-    infiniopTensorDescriptor_t weight,
-    infiniopTensorDescriptor_t pos_weight,
-    infiniopReduction_t reduction);
-
-/**
- * @brief 获取 BCEWithLogits 计算所需的临时空间大小
- */
-__INFINI_C __export infiniStatus_t infiniopGetBCEWithLogitsWorkspaceSize(
-    infiniopBCEWithLogitsDescriptor_t desc,
-    size_t *size);
-
-/**
- * @brief 执行 BCEWithLogits 计算
- * @param desc 算子描述符
- * @param workspace 临时空间指针
- * @param workspace_size 临时空间大小
- * @param out 输出数据指针
- * @param logits Logits 数据指针
- * @param target Target 数据指针
- * @param weight 权重数据指针 (可选，传 NULL 表示权重全为 1)
- * @param pos_weight 正样本权重数据指针 (可选，传 NULL 表示权重全为 1)
- * @param stream 计算流
- */
-__INFINI_C __export infiniStatus_t infiniopBCEWithLogits(
-    infiniopBCEWithLogitsDescriptor_t desc,
-    void *workspace,
-    size_t workspace_size,
-    void *out,
-    const void *logits,
-    const void *target,
-    const void *weight,
-    const void *pos_weight,
-    void *stream);
-
-/**
- * @brief 销毁 BCEWithLogits 算子描述符
- */
-__INFINI_C __export infiniStatus_t infiniopDestroyBCEWithLogitsDescriptor(
-    infiniopBCEWithLogitsDescriptor_t desc);
-
-#endif

include/infiniop/ops/cdist.h

-#ifndef __INFINIOP_CDIST_API_H__
-#define __INFINIOP_CDIST_API_H__
-
-#include "../operator_descriptor.h"
-
-// 定义 cdist 算子描述符类型
-typedef struct InfiniopDescriptor *infiniopCdistDescriptor_t;
-
-/**
- * @brief 创建 Cdist 算子描述符
- * @param handle 算子句柄
- * @param desc_ptr 指向返回的描述符指针
- * @param y 输出张量描述符 (Shape: M x N)
- * @param x1 输入张量1描述符 (Shape: M x D)
- * @param x2 输入张量2描述符 (Shape: N x D)
- * @param p 范数阶数 (L-p norm)
- */
-__INFINI_C __export infiniStatus_t infiniopCreateCdistDescriptor(
-    infiniopHandle_t handle,
-    infiniopCdistDescriptor_t *desc_ptr, // 注意这里应该是具体类型的指针
-    infiniopTensorDescriptor_t y_desc,
-    infiniopTensorDescriptor_t x1_desc,
-    infiniopTensorDescriptor_t x2_desc,
-    double p);
-
-/**
- * @brief 获取 Cdist 计算所需的临时空间大小
- */
-__INFINI_C __export infiniStatus_t infiniopGetCdistWorkspaceSize(infiniopCdistDescriptor_t desc,
-                                                                 size_t *size);
-
-/**
- * @brief 执行 Cdist 计算
- * @param desc 算子描述符
- * @param workspace 临时空间指针
- * @param workspace_size 临时空间大小
- * @param y 输出数据指针
- * @param x1 输入1数据指针
- * @param x2 输入2数据指针
- * @param stream 计算流 (CUDA stream 等)
- */
-__INFINI_C __export infiniStatus_t infiniopCdist(
-    infiniopCdistDescriptor_t desc,
-    void *workspace,
-    size_t workspace_size,
-    void *y,
-    const void *x1,
-    const void *x2,
-    void *stream);
-
-/**
- * @brief 销毁 Cdist 算子描述符
- */
-__INFINI_C __export infiniStatus_t infiniopDestroyCdistDescriptor(infiniopCdistDescriptor_t desc);
-
-#endif

include/infiniop/ops/reciprocal.h

-#ifndef __INFINIOP_RECIPROCAL_API_H__
-#define __INFINIOP_RECIPROCAL_API_H__
-
-#include "../operator_descriptor.h"
-
-typedef struct InfiniopDescriptor *infiniopReciprocalDescriptor_t;
-
-__INFINI_C __export infiniStatus_t infiniopCreateReciprocalDescriptor(infiniopHandle_t handle,
-                                                                      infiniopReciprocalDescriptor_t *desc_ptr,
-                                                                      infiniopTensorDescriptor_t y,
-                                                                      infiniopTensorDescriptor_t x);
-
-__INFINI_C __export infiniStatus_t infiniopGetReciprocalWorkspaceSize(infiniopReciprocalDescriptor_t desc, size_t *size);
-
-__INFINI_C __export infiniStatus_t infiniopReciprocal(infiniopReciprocalDescriptor_t desc,
-                                                      void *workspace,
-                                                      size_t workspace_size,
-                                                      void *y,
-                                                      const void *x,
-                                                      void *stream);
-
-__INFINI_C __export infiniStatus_t infiniopDestroyReciprocalDescriptor(infiniopReciprocalDescriptor_t desc);
-
-#endif

python/infinicore/__init__.py

@@ -49,14 +49,8 @@ from infinicore.dtype import (
 )
 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.all import all
-from infinicore.ops.atanh import atanh
 from infinicore.ops.attention import attention
-from infinicore.ops.binary_cross_entropy_with_logits import (
-    binary_cross_entropy_with_logits,
-)
-from infinicore.ops.cdist import cdist
 from infinicore.ops.cross_entropy import cross_entropy
 from infinicore.ops.equal import equal
 from infinicore.ops.kv_caching import kv_caching
@@ -69,7 +63,6 @@ from infinicore.ops.paged_attention import paged_attention
 from infinicore.ops.paged_attention_prefill import paged_attention_prefill
 from infinicore.ops.paged_caching import paged_caching
 from infinicore.ops.rearrange import rearrange
-from infinicore.ops.reciprocal import reciprocal
 from infinicore.ops.squeeze import squeeze
 from infinicore.ops.sum import sum
 from infinicore.ops.topk import topk

python/infinicore/nn/functional/__init__.py

 from .avg_pool1d import avg_pool1d
-from .binary_cross_entropy_with_logits import binary_cross_entropy_with_logits
 from .causal_softmax import causal_softmax
 from .embedding import embedding
 from .flash_attention import flash_attention
@@ -19,7 +18,6 @@ __all__ = [
     "embedding",
     "flash_attention",
     "linear",
-    "binary_cross_entropy_with_logits",
     "random_sample",
     "rms_norm",
     "RopeAlgo",

python/infinicore/nn/functional/binary_cross_entropy_with_logits.py

-from infinicore.lib import _infinicore
-from infinicore.tensor import Tensor
-
-
-def binary_cross_entropy_with_logits(
-    input: Tensor,
-    target: Tensor,
-    weight: Tensor | None = None,
-    pos_weight: Tensor | None = None,
-    reduction: str = "mean",
-    *,
-    out: Tensor | None = None,
-) -> Tensor:
-    """Binary cross entropy loss with logits.
-
-    This wraps the underlying C++/CUDA implementation exposed via `_infinicore`.
-
-    The low-level binding treats missing ``weight`` / ``pos_weight`` via
-    default-constructed tensors. Here we avoid passing ``None`` down and
-    instead omit arguments when they are not provided, so pybind11 uses
-    its defaults.
-    """
-
-    # Out-of-place API
-    if out is None:
-        # Neither weight nor pos_weight
-        if weight is None and pos_weight is None:
-            return Tensor(
-                _infinicore.binary_cross_entropy_with_logits(
-                    input._underlying,
-                    target._underlying,
-                    reduction=reduction,
-                )
-            )
-
-        # weight provided only
-        if weight is not None and pos_weight is None:
-            return Tensor(
-                _infinicore.binary_cross_entropy_with_logits(
-                    input._underlying,
-                    target._underlying,
-                    weight._underlying,
-                    reduction=reduction,
-                )
-            )
-
-        # pos_weight provided only
-        if weight is None and pos_weight is not None:
-            return Tensor(
-                _infinicore.binary_cross_entropy_with_logits(
-                    input._underlying,
-                    target._underlying,
-                    pos_weight=pos_weight._underlying,
-                    reduction=reduction,
-                )
-            )
-
-        # both provided
-        return Tensor(
-            _infinicore.binary_cross_entropy_with_logits(
-                input._underlying,
-                target._underlying,
-                weight._underlying,
-                pos_weight._underlying,
-                reduction,
-            )
-        )
-
-    # In-place-style API with explicit out
-    if weight is None and pos_weight is None:
-        _infinicore.binary_cross_entropy_with_logits_(
-            out._underlying,
-            input._underlying,
-            target._underlying,
-            reduction=reduction,
-        )
-    elif weight is not None and pos_weight is None:
-        _infinicore.binary_cross_entropy_with_logits_(
-            out._underlying,
-            input._underlying,
-            target._underlying,
-            weight._underlying,
-            reduction=reduction,
-        )
-    elif weight is None and pos_weight is not None:
-        _infinicore.binary_cross_entropy_with_logits_(
-            out._underlying,
-            input._underlying,
-            target._underlying,
-            pos_weight=pos_weight._underlying,
-            reduction=reduction,
-        )
-    else:
-        _infinicore.binary_cross_entropy_with_logits_(
-            out._underlying,
-            input._underlying,
-            target._underlying,
-            weight._underlying,
-            pos_weight._underlying,
-            reduction,
-        )
-
-    return out

python/infinicore/ops/addcmul.py

-from infinicore.lib import _infinicore
-from infinicore.tensor import Tensor
-
-
-def addcmul(input, tensor1, tensor2, value=1.0, *, out=None):
-    if out is None:
-        return Tensor(
-            _infinicore.addcmul(
-                input._underlying,
-                tensor1._underlying,
-                tensor2._underlying,
-                float(value),
-            )
-        )
-
-    _infinicore.addcmul_(
-        out._underlying,
-        input._underlying,
-        tensor1._underlying,
-        tensor2._underlying,
-        float(value),
-    )
-
-    return out

python/infinicore/ops/atanh.py

-from infinicore.lib import _infinicore
-from infinicore.tensor import Tensor
-
-
-def atanh(input, *, out=None):
-    if out is None:
-        return Tensor(_infinicore.atanh(input._underlying))
-
-    _infinicore.atanh_(out._underlying, input._underlying)
-
-    return out

python/infinicore/ops/binary_cross_entropy_with_logits.py

-from infinicore.lib import _infinicore
-from infinicore.tensor import Tensor
-
-
-def binary_cross_entropy_with_logits(
-    input, target, weight=None, pos_weight=None, reduction="mean", *, out=None
-):
-    """
-    input: Tensor (logits)
-    target: Tensor (labels)
-    weight: Tensor (optional, sample-wise weight)
-    pos_weight: Tensor (optional, class-wise weight)
-    reduction: str ('none', 'mean', 'sum')
-    """
-
-    # 提取底层 C++ 对象，处理可选 Tensor
-    weight_raw = weight._underlying if weight is not None else None
-    pos_weight_raw = pos_weight._underlying if pos_weight is not None else None
-
-    if out is None:
-        # 调用非原地接口，返回新创建的 Tensor
-        return Tensor(
-            _infinicore.binary_cross_entropy_with_logits(
-                input._underlying,
-                target._underlying,
-                weight_raw,
-                pos_weight_raw,
-                str(reduction),
-            )
-        )
-
-    # 调用显式指定输出的接口 (binary_cross_entropy_with_logits_)
-    _infinicore.binary_cross_entropy_with_logits_(
-        out._underlying,
-        input._underlying,
-        target._underlying,
-        weight_raw,
-        pos_weight_raw,
-        str(reduction),
-    )
-
-    return out

python/infinicore/ops/cdist.py

-from infinicore.lib import _infinicore
-from infinicore.tensor import Tensor
-
-
-def cdist(x1, x2, p=2.0, *, out=None):
-    """
-    计算两组向量集合中每一对向量之间的 p-norm 距离。
-
-    参数:
-        x1 (Tensor): 形状为 (M, D) 的输入张量。
-        x2 (Tensor): 形状为 (N, D) 的输入张量。
-        p (float): p-norm 的阶数，默认为 2.0。
-        out (Tensor, optional): 结果输出张量。
-
-    返回:
-        Tensor: 形状为 (M, N) 的距离矩阵。
-    """
-    if out is None:
-        # 非原地操作：由底层 C++ 接口根据 x1, x2 推导形状并创建新 Tensor
-        return Tensor(
-            _infinicore.cdist(
-                x1._underlying,
-                x2._underlying,
-                float(p),
-            )
-        )
-
-    # 原地/指定输出操作：结果写入用户提供的 out 张量
-    _infinicore.cdist_(
-        out._underlying,
-        x1._underlying,
-        x2._underlying,
-        float(p),
-    )
-
-    return out