InfiniTensor · zili2004 · Jan 10, 2026
diff --git a/include/infinicore/ops/broadcast_to.hpp b/include/infinicore/ops/broadcast_to.hpp
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+#include <vector>
+
+namespace infinicore::op {
+class BroadcastTo {
+public:
+    // Schema: Output(y), Input(x)
+    using schema = void (*)(Tensor, Tensor);
+    static void execute(Tensor y, Tensor x);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+Tensor broadcast_to(Tensor x, const std::vector<int64_t>& shape);
+void broadcast_to_(Tensor y, Tensor x);
+
+} // namespace infinicore::op
diff --git a/include/infinicore/ops/huber_loss.hpp b/include/infinicore/ops/huber_loss.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class HuberLoss {
+public:
+    // Schema: output, input, target, delta, reduction
+    using schema = void (*)(Tensor, Tensor, Tensor, float, int64_t);
+
+    static void execute(Tensor output, Tensor input, Tensor target, float delta, int64_t reduction);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+// delta 默认为 1.0f，reduction 默认为 1 (MEAN)
+Tensor huber_loss(Tensor input, Tensor target, float delta = 1.0f, int64_t reduction = 1);
+void huber_loss_(Tensor output, Tensor input, Tensor target, float delta, int64_t reduction);
+
+} // namespace infinicore::op
diff --git a/include/infinicore/ops/linear.hpp b/include/infinicore/ops/linear.hpp
@@ -3,6 +3,7 @@
 #include "common/op.hpp"
 #include <optional>
 
+
 namespace infinicore::op {
 
 Tensor linear(Tensor input, Tensor weight, std::optional<Tensor> bias);

diff --git a/include/infinicore/ops/softplus.hpp b/include/infinicore/ops/softplus.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class Softplus {
+public:
+    // 修改 1: Schema 增加 float beta, float threshold
+    using schema = void (*)(Tensor, Tensor, float, float);
+    static void execute(Tensor y, Tensor x, float beta, float threshold);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+// default: beta = 1.0, threshold = 20.0
+Tensor softplus(Tensor x, float beta = 1.0f, float threshold = 20.0f);
+
+void softplus_(Tensor y, Tensor x, float beta = 1.0f, float threshold = 20.0f);
+
+} // namespace infinicore::op
diff --git a/include/infinicore/ops/softsign.hpp b/include/infinicore/ops/softsign.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+class Softsign {
+public:
+    using schema = void (*)(Tensor, Tensor);
+    static void execute(Tensor y, Tensor x);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+// 返回新 Tensor 的函数接口
+Tensor softsign(Tensor x);
+void softsign_(Tensor y, Tensor x);
+} // namespace infinicore::op
diff --git a/include/infiniop.h b/include/infiniop.h
@@ -27,13 +27,16 @@
 #include "infiniop/ops/sigmoid.h"
 #include "infiniop/ops/silu.h"
 #include "infiniop/ops/softmax.h"
-#include "infiniop/ops/softplus.h"
 #include "infiniop/ops/sub.h"
 #include "infiniop/ops/swiglu.h"
 #include "infiniop/ops/tanh.h"
 #include "infiniop/ops/topkrouter.h"
 #include "infiniop/ops/topksoftmax.h"
 #include "infiniop/ops/zeros.h"
+#include "infiniop/ops/broadcast_to.h"
+#include "infiniop/ops/softplus.h"
+#include "infiniop/ops/softsign.h"
+#include "infiniop/ops/huber_loss.h"
 #include "infiniop/tensor_descriptor.h"
 
 #endif // __INFINIOP_API_H__
diff --git a/include/infiniop/ops/broadcast_to.h b/include/infiniop/ops/broadcast_to.h
@@ -0,0 +1,24 @@
+#ifndef __INFINIOP_BROADCAST_TO_API_H__
+#define __INFINIOP_BROADCAST_TO_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopBroadcastToDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateBroadcastToDescriptor(infiniopHandle_t handle,
+                                                                infiniopBroadcastToDescriptor_t *desc_ptr,
+                                                                infiniopTensorDescriptor_t y,
+                                                                infiniopTensorDescriptor_t x);
+
+__C __export infiniStatus_t infiniopGetBroadcastToWorkspaceSize(infiniopBroadcastToDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopBroadcastTo(infiniopBroadcastToDescriptor_t desc,
+                                                void *workspace,
+                                                size_t workspace_size,
+                                                void *y,
+                                                const void *x,
+                                                void *stream);
+
+__C __export infiniStatus_t infiniopDestroyBroadcastToDescriptor(infiniopBroadcastToDescriptor_t desc);
+
+#endif
diff --git a/include/infiniop/ops/huber_loss.h b/include/infiniop/ops/huber_loss.h
@@ -0,0 +1,28 @@
+#ifndef __INFINIOP_HUBER_LOSS_API_H__
+#define __INFINIOP_HUBER_LOSS_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopHuberLossDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateHuberLossDescriptor(infiniopHandle_t handle,
+                                                              infiniopHuberLossDescriptor_t *desc_ptr,
+                                                              infiniopTensorDescriptor_t output,
+                                                              infiniopTensorDescriptor_t input,
+                                                              infiniopTensorDescriptor_t target,
+                                                              float delta,
+                                                              int reduction);
+
+__C __export infiniStatus_t infiniopGetHuberLossWorkspaceSize(infiniopHuberLossDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopHuberLoss(infiniopHuberLossDescriptor_t desc,
+                                              void *workspace,
+                                              size_t workspace_size,
+                                              void *output,
+                                              const void *input,
+                                              const void *target,
+                                              void *stream);
+
+__C __export infiniStatus_t infiniopDestroyHuberLossDescriptor(infiniopHuberLossDescriptor_t desc);
+
+#endif // __INFINIOP_HUBER_LOSS_API_H__
diff --git a/include/infiniop/ops/softplus.h b/include/infiniop/ops/softplus.h
@@ -1,24 +1,38 @@
-#ifndef __INFINIOP_SOFTPLUS_API_H__
-#define __INFINIOP_SOFTPLUS_API_H__
+#ifndef __INFINIOP_OPS_SOFTPLUS_H__
+#define __INFINIOP_OPS_SOFTPLUS_H__
+#include "../tensor_descriptor.h"
 
-#include "../operator_descriptor.h"
-
-typedef struct InfiniopDescriptor *infiniopSoftplusDescriptor_t;
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-__C __export infiniStatus_t infiniopCreateSoftplusDescriptor(infiniopHandle_t handle,
-                                                             infiniopSoftplusDescriptor_t *desc_ptr,
-                                                             infiniopTensorDescriptor_t y,
-                                                             infiniopTensorDescriptor_t x);
+typedef struct InfiniopSoftplusDescriptor *infiniopSoftplusDescriptor_t;
+__C __export infiniStatus_t infiniopCreateSoftplusDescriptor(
+    infiniopHandle_t handle,
+    infiniopSoftplusDescriptor_t *desc_ptr,
+    infiniopTensorDescriptor_t y_desc,
+    infiniopTensorDescriptor_t x_desc,
+    float beta,       
+    float threshold   
+);
 
-__C __export infiniStatus_t infiniopGetSoftplusWorkspaceSize(infiniopSoftplusDescriptor_t desc, size_t *size);
+__C __export infiniStatus_t infiniopGetSoftplusWorkspaceSize(
+    infiniopSoftplusDescriptor_t desc, 
+    size_t *size);
 
-__C __export infiniStatus_t infiniopSoftplus(infiniopSoftplusDescriptor_t desc,
-                                             void *workspace,
-                                             size_t workspace_size,
-                                             void *y,
-                                             const void *x,
-                                             void *stream);
+__C __export infiniStatus_t infiniopSoftplus(
+    infiniopSoftplusDescriptor_t desc,
+    void *workspace,
+    size_t workspace_size,
+    void *y,
+    const void *x,
+    void *stream);
 
-__C __export infiniStatus_t infiniopDestroySoftplusDescriptor(infiniopSoftplusDescriptor_t desc);
+__C __export infiniStatus_t infiniopDestroySoftplusDescriptor(
+    infiniopSoftplusDescriptor_t desc);
 
+#ifdef __cplusplus
+}
 #endif
+
+#endif // __INFINIOP_OPS_SOFTPLUS_H__
diff --git a/include/infiniop/ops/softsign.h b/include/infiniop/ops/softsign.h
@@ -0,0 +1,25 @@
+
+#ifndef __INFINIOP_SOFTSIGN_API_H__
+#define __INFINIOP_SOFTSIGN_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopSoftsignDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateSoftsignDescriptor(infiniopHandle_t handle,
+                                                             infiniopSoftsignDescriptor_t *desc_ptr,
+                                                             infiniopTensorDescriptor_t y,
+                                                             infiniopTensorDescriptor_t x);
+
+__C __export infiniStatus_t infiniopGetSoftsignWorkspaceSize(infiniopSoftsignDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopSoftsign(infiniopSoftsignDescriptor_t desc,
+                                             void *workspace,
+                                             size_t workspace_size,
+                                             void *y,
+                                             const void *x,
+                                             void *stream);
+
+__C __export infiniStatus_t infiniopDestroySoftsignDescriptor(infiniopSoftsignDescriptor_t desc);
+
+#endif
diff --git a/python/infinicore/__init__.py b/python/infinicore/__init__.py
@@ -51,6 +51,7 @@
 from infinicore.ops.rearrange import rearrange
 from infinicore.ops.squeeze import squeeze
 from infinicore.ops.unsqueeze import unsqueeze
+from infinicore.ops.broadcast_to import broadcast_to
 from infinicore.tensor import (
     Tensor,
     empty,
@@ -125,6 +126,7 @@
     "paged_attention",
     "paged_attention_prefill",
     "ones",
+    "broadcast_to",
     "strided_empty",
     "strided_from_blob",
     "zeros",

diff --git a/python/infinicore/nn/functional/__init__.py b/python/infinicore/nn/functional/__init__.py
@@ -5,6 +5,9 @@
 from .rms_norm import rms_norm
 from .rope import RopeAlgo, rope
 from .silu import silu
+from .softplus import softplus
+from .softsign import softsign
+from .huber_loss import huber_loss
 from .swiglu import swiglu
 
 __all__ = [
@@ -17,4 +20,7 @@
     "embedding",
     "rope",
     "RopeAlgo",
+    "softplus",
+    "siftsign",
+    "huber_loss",
 ]
diff --git a/python/infinicore/nn/functional/huber_loss.py b/python/infinicore/nn/functional/huber_loss.py
@@ -0,0 +1,50 @@
+from typing import Optional
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+_REDUCTION_MODES = {
+    "none": 0,
+    "mean": 1,
+    "sum": 2,
+}
+
+def huber_loss(
+    input: Tensor, 
+    target: Tensor, 
+    delta: float = 1.0, 
+    reduction: str = "mean", 
+    *, 
+    out: Optional[Tensor] = None
+) -> Tensor:
+    r"""Creates a criterion that uses a squared term if the absolute
+    element-wise error falls below delta and a delta-scaled L1 term otherwise.
+    """
+
+    if not input.is_contiguous():
+        input = input.contiguous()
+    if not target.is_contiguous():
+        target = target.contiguous()
+
+    # 解析 reduction 参数
+    if reduction not in _REDUCTION_MODES:
+        raise ValueError(f"{reduction} is not a valid value for reduction")
+    reduction_val = _REDUCTION_MODES[reduction]
+
+    if out is not None:
+        _infinicore.huber_loss_(
+            out._underlying,
+            input._underlying,
+            target._underlying,
+            delta,
+            reduction_val
+        )
+        return out
+
+    return Tensor(
+        _infinicore.huber_loss(
+            input._underlying,
+            target._underlying,
+            delta,
+            reduction_val
+        )
+    )
diff --git a/python/infinicore/nn/functional/linear.py b/python/infinicore/nn/functional/linear.py
@@ -1,6 +1,9 @@
 from infinicore.lib import _infinicore
 from infinicore.tensor import Tensor
 
+__all__ = ["linear"]
+
+
 
 def linear(input: Tensor, weight: Tensor, bias=None, *, out=None) -> Tensor:
     r"""Applies a linear transformation to the incoming data: y=xA^T+b."""

diff --git a/python/infinicore/nn/functional/softplus.py b/python/infinicore/nn/functional/softplus.py
@@ -0,0 +1,13 @@
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+
+def softplus(input, beta=1, threshold=20, *, out=None):
+    if out is None:
+        # 修改：将 beta 和 threshold 传递给底层 C++
+        return Tensor(_infinicore.softplus(input._underlying, beta, threshold))
+
+    # 修改：将 beta 和 threshold 传递给底层 C++ (In-place)
+    _infinicore.softplus_(out._underlying, input._underlying, beta, threshold)
+
+    return out
diff --git a/python/infinicore/nn/functional/softsign.py b/python/infinicore/nn/functional/softsign.py
@@ -0,0 +1,11 @@
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+
+def softsign(input, *, out=None):
+    if out is None:
+        return Tensor(_infinicore.softsign(input._underlying))
+
+    _infinicore.softsign_(out._underlying, input._underlying)
+
+    return out
diff --git a/python/infinicore/ops/broadcast_to.py b/python/infinicore/ops/broadcast_to.py
@@ -0,0 +1,11 @@
+from infinicore.lib import _infinicore
+from infinicore.tensor import Tensor
+
+# 修改说明：将参数名 'shape' 改为 'size'，以匹配测试用例中的调用方式 kwargs={size=...}
+def broadcast_to(input, size, *, out=None):
+    if out is None:
+        return Tensor(_infinicore.broadcast_to(input._underlying, size))
+
+    _infinicore.broadcast_to_(out._underlying, input._underlying)
+
+    return out