Merge pull request #567 from gongchensu/feature/add_nn_interface

 #567 - 增加 nn.Module, nn.Parameter,nn.ModuleList类

python/infinicore/nn/__init__.py

 from infinicore.nn import functional
+from infinicore.nn.modules import *  # noqa: F403
+from infinicore.nn.parameter import InfiniCoreParameter as Parameter
 
-__all__ = ["functional"]
+__all__ = ["functional", "Parameter"]

python/infinicore/nn/modules/__init__.py

+from .container import InfiniCoreModuleList as ModuleList
+from .module import InfiniCoreModule as Module
+
+__all__ = ["ModuleList", "Module"]

python/infinicore/nn/modules/container.py

+# ============================================
+# Copyright (c) 2025, InfiniCore
+#
+# This file implements InfiniCoreModuleList, which is similar to torch.nn.ModuleList
+# but based on InfiniCoreModule for inference purposes.
+
+import operator
+from collections import OrderedDict
+from itertools import chain
+from typing import Iterator, List, Optional, Sequence, TypeVar, Union
+
+from .module import InfiniCoreModule as Module
+
+# Define type variable for module compatibility (supports InfiniCoreModule)
+ModuleType = TypeVar("ModuleType", bound=Union["Module"])
+
+
+class InfiniCoreModuleList(Module):
+    r"""Holds submodules in a list.
+
+    InfiniCoreModuleList can be indexed like a regular Python list, but
+    modules it contains are properly registered, and will be visible by all
+    InfiniCoreModule methods.
+
+    Args:
+        modules (iterable, optional): an iterable of modules to add
+
+    Example::
+
+        >>> class MyModel(InfiniCoreModule):
+        ...     def __init__(self):
+        ...         super().__init__()
+        ...         self.linears = InfiniCoreModuleList([
+        ...             torch.nn.Linear(10, 10) for i in range(10)
+        ...         ])
+        ...
+        ...     def forward(self, x):
+        ...         # ModuleList can act as an iterable, or be indexed using ints
+        ...         for i, l in enumerate(self.linears):
+        ...             x = self.linears[i // 2](x) + l(x)
+        ...         return x
+    """
+
+    def __init__(self, modules: Optional[Sequence[ModuleType]] = None):
+        super().__init__()
+        if modules is not None:
+            self += modules
+
+    def _get_abs_string_index(self, idx):
+        """Get the absolute index for the list of modules."""
+        idx = operator.index(idx)
+        if not (-len(self) <= idx < len(self)):
+            raise IndexError(f"index {idx} is out of range")
+        if idx < 0:
+            idx += len(self)
+        return str(idx)
+
+    def __getitem__(
+        self, idx: Union[int, slice]
+    ) -> Union[ModuleType, "InfiniCoreModuleList"]:
+        if isinstance(idx, slice):
+            return self.__class__(list(self._modules.values())[idx])
+        else:
+            return self._modules[self._get_abs_string_index(idx)]
+
+    def __setitem__(self, idx: int, module: ModuleType) -> None:
+        idx = self._get_abs_string_index(idx)
+        # Use add_module to register module
+        self.add_module(idx, module)
+
+    def __delitem__(self, idx: Union[int, slice]) -> None:
+        if isinstance(idx, slice):
+            indices_to_delete = list(range(len(self._modules)))[idx]
+            for k in indices_to_delete:
+                if str(k) in self._modules:
+                    del self._modules[str(k)]
+        else:
+            idx_str = self._get_abs_string_index(idx)
+            if idx_str in self._modules:
+                del self._modules[idx_str]
+
+        # To preserve numbering, self._modules is being reconstructed with modules after deletion
+        if len(self._modules) > 0:
+            str_indices = [str(i) for i in range(len(self._modules))]
+            self._modules = OrderedDict(list(zip(str_indices, self._modules.values())))
+
+    def __len__(self) -> int:
+        return len(self._modules)
+
+    def __iter__(self) -> Iterator[ModuleType]:
+        return iter(self._modules.values())
+
+    def __iadd__(self, modules: Sequence[ModuleType]) -> "InfiniCoreModuleList":
+        return self.extend(modules)
+
+    def __add__(
+        self, other: Union[Sequence[ModuleType], "InfiniCoreModuleList"]
+    ) -> "InfiniCoreModuleList":
+        r"""Return a new InfiniCoreModuleList by concatenating with another iterable.
+
+        Args:
+            other (iterable): iterable of modules to concatenate
+        """
+        if not isinstance(other, (list, tuple, InfiniCoreModuleList)):
+            raise TypeError(
+                f"InfiniCoreModuleList can only be concatenated with list, tuple, or InfiniCoreModuleList, "
+                f"got {type(other).__name__}"
+            )
+
+        combined = InfiniCoreModuleList()
+        for i, module in enumerate(chain(self, other)):
+            combined.add_module(str(i), module)
+        return combined
+
+    def append(self, module: ModuleType) -> "InfiniCoreModuleList":
+        r"""Append a given module to the end of the list.
+
+        Args:
+            module (InfiniCoreModule): module to append
+        """
+        self.add_module(str(len(self)), module)
+        return self
+
+    def extend(self, modules: Sequence[ModuleType]) -> "InfiniCoreModuleList":
+        r"""Append modules from a Python iterable to the end of the list.
+
+        Args:
+            modules (iterable): iterable of modules to append
+        """
+        if not isinstance(modules, (list, tuple)):
+            try:
+                modules = list(modules)
+            except TypeError:
+                raise TypeError(
+                    f"InfiniCoreModuleList.extend should be called with an "
+                    f"iterable, but got {type(modules).__name__}"
+                )
+
+        offset = len(self)
+        for i, module in enumerate(modules):
+            self.add_module(str(offset + i), module)
+        return self
+
+    def insert(self, index: int, module: ModuleType) -> None:
+        r"""Insert a given module before a given index in the list.
+
+        Args:
+            index (int): index to insert.
+            module ( InfiniCoreModule): module to insert
+        """
+        for i in range(len(self._modules), index, -1):
+            self._modules[str(i)] = self._modules[str(i - 1)]
+        self._modules[str(index)] = module
+
+    def pop(self, idx: int = -1) -> ModuleType:
+        r"""Remove and return a module at the given index.
+
+        Args:
+            idx (int): index of the module to pop. Default: -1 (last module)
+
+        Returns:
+            Module: the module that was removed
+        """
+        idx_str = self._get_abs_string_index(idx)
+        module = self._modules[idx_str]
+        # Use __delitem__ to ensure proper cleanup
+        self.__delitem__(int(idx_str))
+        return module
+
+    def __repr__(self) -> str:
+        """Return a string representation of the ModuleList."""
+        if len(self) == 0:
+            return self.__class__.__name__ + "()"
+
+        lines = []
+        for i, module in enumerate(self):
+            lines.append(f"({i}): {repr(module)}")
+
+        main_str = self.__class__.__name__ + "(\n  "
+        main_str += "\n  ".join(lines) + "\n)"
+        return main_str
+
+    def __dir__(self) -> List[str]:
+        """Return a list of attribute names, excluding numeric keys."""
+        keys = super().__dir__()
+        # Filter out numeric keys to avoid cluttering dir() output
+        keys = [key for key in keys if not key.isdigit()]
+        return keys

python/infinicore/nn/parameter.py

+# Copyright (c) 2025, InfiniCore
+#
+# This file contains modified code derived from PyTorch's `torch.nn.Parameter`
+# implementation, which is licensed under the BSD 3-Clause License.
+#
+# The modifications include adaptations for the InfiniCore framework.
+#
+# Original PyTorch source:
+# https://github.com/pytorch/pytorch/blob/main/torch/nn/parameter.py
+#
+# Referencing PyTorch v2.4.0
+#
+# The use of this file is governed by the BSD 3-Clause License.
+
+
+from ..tensor import Tensor
+
+
+class InfiniCoreParameter(Tensor):
+    r"""A kind of Tensor that is to be considered a module parameter."""
+
+    def __init__(self, data=None):
+        if not isinstance(data, Tensor):
+            raise ValueError("The `data` variable must be of type `infinicore.Tensor`.")
+        super().__init__(data._underlying)
+
+    def __repr__(self):
+        return "Parameter containing:\n" + super().__repr__()
+
+    def __deepcopy__(self, memo):
+        raise ValueError("not supported!")
+
+    def __reduce_ex__(self, proto):
+        raise ValueError("not supported!")

test/infinicore/nn/Module.py

+# ============================================================
+# 0. infinicore 包导入，配置测试用 safetensors 临时存储路径
+# ============================================================
+import os
+import sys
+
+sys.path.append(
+    os.path.abspath(os.path.join(os.path.dirname(__file__), "../../python/infinicore"))
+)
+
+save_dir = os.path.join(os.path.dirname(__file__), "../../tmp")
+os.makedirs(save_dir, exist_ok=True)
+save_path = os.path.join(save_dir, "torch_convnet_with_param.safetensors")
+
+
+import infinicore  # noqa: E402
+from infinicore.nn import Module  # noqa: E402
+
+
+# ============================================================
+# 1. 定义模型
+# ============================================================
+device_str = "cuda"
+
+
+class InfiniCoreNet(Module):
+    def __init__(self):
+        super().__init__()
+        self.a = infinicore.nn.Parameter(
+            infinicore.empty(
+                (1, 2, 3),
+                dtype=infinicore.float32,
+                device=infinicore.device(device_str),
+            )
+        )
+        self.b = infinicore.nn.Parameter(
+            infinicore.empty(
+                (1, 2, 3),
+                dtype=infinicore.float32,
+                device=infinicore.device(device_str),
+            )
+        )
+
+    def forward(self):
+        return infinicore.add(self.a, self.b)
+
+infinicore_model_infer = InfiniCoreNet()
+# ============================================================
+# 2. 加载权重
+# ============================================================
+
+params_dict = {
+    "a": infinicore.empty(
+        (1, 2, 3), dtype=infinicore.float32, device=infinicore.device(device_str, 0)
+    ),
+    "b": infinicore.empty(
+        (1, 2, 3), dtype=infinicore.float32, device=infinicore.device(device_str, 0)
+    ),
+}
+infinicore_model_infer.load_state_dict(params_dict)
+
+# ============================================================
+# 3. 计算
+# ============================================================
+infinicore_model_out = infinicore_model_infer()
+ref_out = infinicore.add(params_dict["a"], params_dict["b"])
+
+
+# ============================================================
+# 4. 对比结果
+# ============================================================
+print("InfiniCoreModule 与 Torch (CPU) 最大误差: 手动查看 ")
+infinicore_model_out.debug()
+ref_out.debug()
+
+
+# ============================================================
+# 5. to测试，buffer测试
+# ============================================================
+# 等待添加

test/infinicore/nn/ModuleList.py

+import os
+
+# ============================================================
+# 0. infinicore 包导入，配置测试用 safetensors 临时存储路径
+# ============================================================
+import sys
+
+import safetensors
+import safetensors.torch
+import torch
+import torch.nn as nn
+
+sys.path.append(
+    os.path.abspath(os.path.join(os.path.dirname(__file__), "../../python/infinicore"))
+)
+
+# 使用临时目录，如果不存在则自动创建
+save_dir = os.path.join(os.path.dirname(__file__), "../../tmp")
+os.makedirs(save_dir, exist_ok=True)
+save_path = os.path.join(save_dir, "torch_modulelist_with_param.safetensors")
+
+
+def test():
+    # ============================================================
+    # 1. 使用 PyTorch 定义并保存模型（使用 torch.nn.ModuleList）
+    # ============================================================
+    class TorchModuleListNet(nn.Module):
+        def __init__(self, in_ch=3, hidden_ch=8, out_ch=3):
+            super().__init__()
+            # 使用 torch.nn.ModuleList
+            self.layers = nn.ModuleList(
+                [
+                    nn.Conv2d(in_ch, hidden_ch, kernel_size=3, padding=1),
+                    nn.BatchNorm2d(hidden_ch),
+                    nn.ReLU(),
+                    nn.Conv2d(hidden_ch, hidden_ch, kernel_size=3, padding=1),
+                    nn.BatchNorm2d(hidden_ch),
+                    nn.ReLU(),
+                    nn.Conv2d(hidden_ch, out_ch, kernel_size=1),
+                ]
+            )
+
+            # 自定义 Parameter
+            self.scale = nn.Parameter(torch.ones(1) * 0.5)
+            self.register_buffer("offset", torch.tensor(0.1))
+
+        def forward(self, x):
+            # 遍历 ModuleList 中的所有层
+            for layer in self.layers:
+                x = layer(x)
+            # 应用自定义参数和 buffer
+            x = x * self.scale + self.offset
+            return x
+
+    # ===== 保存 Torch 模型 =====
+    torch_model = TorchModuleListNet()
+    torch_state_dict = torch_model.state_dict()
+    safetensors.torch.save_file(torch_state_dict, save_path)
+    print("✓ PyTorch 模型已保存")
+
+    # ============================================================
+    # 2. 使用 torch 方式加载并推理
+    # ============================================================
+
+    torch_model_infer = TorchModuleListNet()
+    torch_model_infer.load_state_dict(safetensors.torch.load_file(save_path))
+    torch_model_infer.eval()
+
+    input = torch.rand(1, 3, 8, 8)
+    torch_model_out = torch_model_infer(input)
+    print("✓ Torch 输出：", torch_model_out.detach().numpy().mean())
+
+    # ============================================================
+    # 3. 使用 ModuleList 加载并推理
+    # ============================================================
+
+    from nn.modules import Module, ModuleList
+
+    class InfiniCoreModuleListNet(Module):
+        def __init__(self, in_ch=3, hidden_ch=8, out_ch=3):
+            super().__init__()
+            # 使用 ModuleList
+            self.layers = ModuleList(
+                [
+                    nn.Conv2d(in_ch, hidden_ch, kernel_size=3, padding=1),
+                    nn.BatchNorm2d(hidden_ch),
+                    nn.ReLU(),
+                    nn.Conv2d(hidden_ch, hidden_ch, kernel_size=3, padding=1),
+                    nn.BatchNorm2d(hidden_ch),
+                    nn.ReLU(),
+                    nn.Conv2d(hidden_ch, out_ch, kernel_size=1),
+                ]
+            )
+
+            # 保持与 Torch 模型一致的自定义参数和 buffer
+            self.scale = nn.Parameter(torch.ones(1) * 0.5)
+            self.register_buffer("offset", torch.tensor(0.1))
+
+        def forward(self, x):
+            # 遍历 ModuleList 中的所有层
+            for layer in self.layers:
+                x = layer(x)
+            x = x * self.scale + self.offset
+            return x
+
+    # ===== 使用 ModuleListNet 读取 safetensors 并推理 =====
+    infinicore_model_infer = InfiniCoreModuleListNet()
+    infinicore_model_infer.load_state_dict(safetensors.torch.load_file(save_path))
+    infinicore_model_infer.eval()
+
+    infinicore_model_out = infinicore_model_infer.forward(input)
+    print("✓ InfiniCore 输出：", infinicore_model_out.detach().numpy().mean())
+
+    # ============================================================
+    # 4. 对比结果
+    # ============================================================
+
+    diff = (infinicore_model_out - torch_model_out).abs().max().item()
+    print(f"✓ ModuleList 与 Torch 最大误差: {diff:.8f}")
+    if diff < 1e-9:
+        print("✓ ModuleList 与 Torch 精度一致.")
+    else:
+        print("✗ ModuleList 与 Torch 精度存在差异.")
+
+    # ============================================================
+    # 5. 测试 ModuleList 的基本功能
+    # ============================================================
+
+    print("\n=== 测试 ModuleList 基本功能 ===")
+
+    # 测试 1: 创建和访问
+    module_list = ModuleList([nn.Linear(10, 20), nn.ReLU(), nn.Linear(20, 5)])
+
+    print(f"✓ 创建 ModuleList，长度: {len(module_list)}")
+    print(f"✓ 访问第一个模块: {type(module_list[0]).__name__}")
+    print(f"✓ 访问第二个模块: {type(module_list[1]).__name__}")
+
+    # 测试 2: append
+    module_list.append(nn.Softmax(dim=-1))
+    print(f"✓ append 后长度: {len(module_list)}")
+
+    # 测试 3: extend
+    module_list.extend([nn.Dropout(0.1), nn.Linear(5, 1)])
+    print(f"✓ extend 后长度: {len(module_list)}")
+
+    # 测试 4: 迭代
+    print("✓ 迭代 ModuleList:")
+    for i, module in enumerate(module_list):
+        print(f"  [{i}] {type(module).__name__}")
+
+    # 测试 5: 索引访问
+    print(f"✓ 索引访问 module_list[0]: {type(module_list[0]).__name__}")
+
+    # 测试 6: state_dict
+    state_dict = module_list.state_dict()
+    print(f"✓ state_dict 键数量: {len(state_dict)}")
+    print(f"✓ state_dict 包含模块参数: {any('0.' in k for k in state_dict.keys())}")
+
+    # 测试 7: 使用 ModuleList 的模型
+    class TestNet(Module):
+        def __init__(self):
+            super().__init__()
+            self.layers = ModuleList([nn.Linear(10, 20), nn.ReLU(), nn.Linear(20, 5)])
+
+        def forward(self, x):
+            for layer in self.layers:
+                x = layer(x)
+            return x
+
+    test_model = TestNet()
+    test_input = torch.randn(2, 10)
+    test_output = test_model.forward(test_input)
+    print(f"✓ TestNet 输入形状: {test_input.shape}, 输出形状: {test_output.shape}")
+
+    # 测试 8: __add__ 方法
+    ml1 = ModuleList([nn.Linear(10, 5), nn.ReLU()])
+    ml2 = ModuleList([nn.Linear(5, 3), nn.Sigmoid()])
+    ml3 = ml1 + ml2
+    print(f"✓ __add__ 方法测试: {len(ml1)} + {len(ml2)} = {len(ml3)}")
+    assert len(ml3) == 4, "合并后的长度应该为 4"
+
+    # 测试 9: pop 方法
+    ml4 = ModuleList([nn.Linear(10, 5), nn.ReLU(), nn.Linear(5, 3)])
+    popped = ml4.pop()
+    print(
+        f"✓ pop 方法测试: 弹出后长度 {len(ml4)}, 弹出模块类型 {type(popped).__name__}"
+    )
+    assert len(ml4) == 2, "pop 后长度应该为 2"
+    assert isinstance(popped, nn.Linear), "弹出的应该是 Linear 模块"
+
+    # 测试 10: __repr__ 方法
+    ml5 = ModuleList([nn.Linear(10, 5), nn.ReLU()])
+    repr_str = repr(ml5)
+    print(f"✓ __repr__ 方法测试: 输出包含类名和模块信息")
+    assert "ModuleList" in repr_str or "InfiniCoreModuleList" in repr_str, (
+        "repr 应该包含类名"
+    )
+    assert "Linear" in repr_str, "repr 应该包含模块信息"
+    print(repr_str)
+
+    print("\n=== 所有测试通过! ===")
+
+    # ============================================================
+    # 6. 前向传播集成测试（参考 infinicore_nn_test.py）
+    # ============================================================
+
+    print("\n=== 前向传播集成测试 ===")
+
+    # 使用 ModuleList 创建一个简单的模型
+    class TorchModuleListModel(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.layers = nn.ModuleList(
+                [nn.Linear(10, 20), nn.ReLU(), nn.Linear(20, 5)]
+            )
+            self.scale = nn.Parameter(torch.ones(1) * 0.5)
+            self.register_buffer("offset", torch.tensor(0.1))
+
+        def forward(self, x):
+            for layer in self.layers:
+                x = layer(x)
+            x = x * self.scale + self.offset
+            return x
+
+    class InfiniCoreModuleListModel(Module):
+        def __init__(self):
+            super().__init__()
+            self.layers = ModuleList([nn.Linear(10, 20), nn.ReLU(), nn.Linear(20, 5)])
+            self.scale = nn.Parameter(torch.ones(1) * 0.5)
+            self.register_buffer("offset", torch.tensor(0.1))
+
+        def forward(self, x):
+            for layer in self.layers:
+                x = layer(x)
+            x = x * self.scale + self.offset
+            return x
+
+    # 创建模型
+    torch_model_forward = TorchModuleListModel()
+    infinicore_model_forward = InfiniCoreModuleListModel()
+
+    # 复制权重（确保初始权重一致）
+    infinicore_model_forward.load_state_dict(
+        torch_model_forward.state_dict(), strict=False
+    )
+
+    # 设置为评估模式
+    torch_model_forward.eval()
+    infinicore_model_forward.eval()
+
+    # 创建测试输入
+    test_input = torch.randn(2, 10)
+
+    # 前向传播
+    with torch.no_grad():
+        torch_output = torch_model_forward(test_input)
+        infinicore_output = infinicore_model_forward.forward(test_input)
+
+    # 对比结果
+    diff = (infinicore_output - torch_output).abs().max().item()
+    print(f"✓ 前向传播测试 - 输入形状: {test_input.shape}")
+    print(
+        f"✓ Torch 输出形状: {torch_output.shape}, 均值: {torch_output.detach().numpy().mean():.8f}"
+    )
+    print(
+        f"✓ InfiniCore 输出形状: {infinicore_output.shape}, 均值: {infinicore_output.detach().numpy().mean():.8f}"
+    )
+    print(f"✓ 最大误差: {diff:.8f}")
+
+    if diff < 1e-9:
+        print("✓ 前向传播集成测试通过：ModuleList 与 Torch ModuleList 结果一致！")
+    else:
+        print("✗ 前向传播集成测试失败：存在差异")
+
+    # ============================================================
+    # 7. 混合模块兼容性测试（PyTorch + InfiniCore 模块混合使用）
+    # ============================================================
+
+    print("\n=== 混合模块兼容性测试 ===")
+
+    # 创建一个自定义的 InfiniCore 模块
+    class CustomLinear(Module):
+        def __init__(self, in_features, out_features):
+            super().__init__()
+            self.weight = nn.Parameter(torch.randn(out_features, in_features))
+            self.bias = nn.Parameter(torch.randn(out_features))
+
+        def forward(self, x):
+            return x @ self.weight.t() + self.bias
+
+    # 创建混合 ModuleList（包含 PyTorch 模块和 InfiniCore 模块）
+    mixed_list = ModuleList(
+        [
+            nn.Linear(10, 5),  # PyTorch 模块
+            CustomLinear(5, 3),  # 自定义 InfiniCore 模块
+            nn.ReLU(),  # PyTorch 模块
+        ]
+    )
+
+    print(f"✓ 创建混合 ModuleList，长度: {len(mixed_list)}")
+    print(f"✓ 模块类型: {[type(m).__name__ for m in mixed_list]}")
+
+    # 测试参数注册
+    param_count = sum(1 for _ in mixed_list.parameters())
+    print(f"✓ 参数数量: {param_count}")
+    assert param_count == 4, (
+        f"参数数量应该为 4 (Linear: weight+bias, CustomLinear: weight+bias), 实际为 {param_count}"
+    )
+
+    # 测试 state_dict
+    mixed_state_dict = mixed_list.state_dict()
+    print(f"✓ state_dict 键数量: {len(mixed_state_dict)}")
+    assert len(mixed_state_dict) >= 4, "state_dict 应该包含至少 4 个参数"
+
+    # 测试前向传播
+    test_input_mixed = torch.randn(2, 10)
+    with torch.no_grad():
+        x = test_input_mixed
+        for module in mixed_list:
+            x = module.forward(x)
+    print(f"✓ 混合模块前向传播成功，输出形状: {x.shape}")
+
+    print("✓ 混合模块兼容性测试通过！")

test/infinicore/nn/Parameter.py

+# ============================================================
+# 0. infinicore 包导入，配置测试用 safetensors 临时存储路径
+# ============================================================
+import os
+import sys
+
+
+import torch
+import torch.nn as nn
+
+sys.path.append(
+    os.path.abspath(os.path.join(os.path.dirname(__file__), "../../python/infinicore"))
+)
+
+save_dir = os.path.join(os.path.dirname(__file__), "../../tmp")
+os.makedirs(save_dir, exist_ok=True)
+save_path = os.path.join(save_dir, "infinicore_parameter_test.safetensors")
+
+
+import infinicore  # noqa: E402
+from infinicore.nn import Module, Parameter  # noqa: E402
+
+device_str = "cuda"
+
+
+class InfiniCoreParameterNet(Module):
+    def __init__(self):
+        super().__init__()
+        self.a = infinicore.nn.Parameter(
+            infinicore.empty(
+                (1, 2, 3), dtype=infinicore.float32, device=infinicore.device("cpu", 0)
+            )
+        )
+
+    def forward(self, x):
+        return infinicore.add(self.a, x)
+
+
+infinicore_model_infer = InfiniCoreParameterNet()
+# ============================================================
+# 2. 加载权重
+# ============================================================
+params_dict = {
+    "a": infinicore.empty(
+        (1, 2, 3), dtype=infinicore.float32, device=infinicore.device(device_str, 0)
+    )
+}
+infinicore_model_infer.load_state_dict(params_dict)
+
+
+# ============================================================
+# 3. 计算
+# ============================================================
+x = infinicore.empty(
+    (1, 2, 3), dtype=infinicore.float32, device=infinicore.device(device_str, 0)
+)
+
+infinicore_model_out = infinicore_model_infer(x)
+ref_out = infinicore.add(params_dict["a"], x)
+
+# ============================================================
+# 4. 对比结果
+# ============================================================
+print("InfiniCoreModule 与 Torch (CPU) 最大误差: 手动查看 ")
+infinicore_model_out.debug()
+ref_out.debug()
+
+
+# ============================================================
+# 5. 测试 Parameter 的基本功能
+# ============================================================
+
+print("\n=== 测试 Parameter 基本功能 ===")
+
+# 测试 1: 创建 Parameter
+param1 = infinicore.nn.Parameter(
+    infinicore.empty(
+        (1, 2, 3), dtype=infinicore.float32, device=infinicore.device(device_str, 0)
+    )
+)
+print(f"✓ 创建 Parameter，形状: {param1.shape}")
+# 检查是否是 Parameter 类型（可能是 InfiniCoreParameter 的别名）
+
+assert isinstance(param1, infinicore.nn.Parameter), "应该是 Parameter 类型"
+assert isinstance(param1, infinicore.Tensor), "应该是 torch.Tensor 的子类"
+
+
+# 测试 3: 自动注册到 Module
+class TestModule(Module):
+    def __init__(self):
+        super().__init__()
+        self.weight = infinicore.nn.Parameter(
+            infinicore.empty(
+                (1, 2, 3),
+                dtype=infinicore.float32,
+                device=infinicore.device(device_str),
+            )
+        )
+        self.bias = infinicore.nn.Parameter(
+            infinicore.empty(
+                (1, 2, 3),
+                dtype=infinicore.float32,
+                device=infinicore.device(device_str),
+            )
+        )
+
+
+test_module = TestModule()
+param_count = sum(1 for _ in test_module.parameters())
+print(f"✓ 自动注册到 Module，参数数量: {param_count}")
+assert param_count == 2, f"应该有 2 个参数，实际为 {param_count}"
+
+# 测试 4: 参数访问
+assert test_module.weight is not None, "weight 应该可以访问"
+assert test_module.bias is not None, "bias 应该可以访问"
+print("✓ 参数可以通过属性访问")
+
+# 测试 5: state_dict
+state_dict = test_module.state_dict()
+print(f"✓ state_dict 键数量: {len(state_dict)}")
+assert "weight" in state_dict, "state_dict 应该包含 weight"
+assert "bias" in state_dict, "state_dict 应该包含 bias"
+print(f"✓ state_dict 键: {list(state_dict.keys())}")
+
+# 测试 6: __repr__
+repr_str = repr(param1)
+print(f"✓ __repr__ 方法: 输出包含类名")
+assert "Parameter" in repr_str or "InfiniCoreParameter" in repr_str, "repr 应该包含类名"
+print(repr_str[:100] + "...")
+
+
+# 测试 9: 从 None 创建
+# param_empty = Parameter(None)
+# print(f"✓ 从 None 创建 Parameter，形状: {param_empty.shape}")
+# assert param_empty.shape == torch.Size([0]), "从 None 创建应该是空张量"
+
+
+# 测试 10: 深拷贝
+# import copy
+
+# param_copy = copy.deepcopy(param1)
+# print(f"✓ 深拷贝 Parameter，形状: {param_copy.shape}")
+# assert param_copy.shape == param1.shape, "深拷贝后形状应该相同"
+# assert not torch.equal(param_copy, param1) or id(param_copy) != id(param1), (
+#     "深拷贝应该是新对象"
+# )
+
+print("\n=== 所有测试通过! ===")