Merge pull request #589 from InfiniTensor/issue/566

issue/566: 添加 Python 算子测试

test/infinicore/ops/mse_loss.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+
+# Test cases format: (input_shape, target_shape, input_strides_or_None, reduction_or_None)
+# infinicore.nn.functional.mse_loss(input, target, reduction='mean')
+
+_TEST_CASES_DATA = [
+    ((4, 5), (4, 5), None, None),
+    ((8, 8), (8, 8), (512, 64), "sum"),
+    ((1, 10), (1, 10), None, "mean"),
+    ((16, 100), (16, 100), None, None),
+    ((3, 7), (3, 7), None, "none"),
+    ((2, 2), (2, 2), None, None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float16: {"atol": 1e-3, "rtol": 1e-2},
+    infinicore.float32: {"atol": 1e-5, "rtol": 1e-4},
+    infinicore.bfloat16: {"atol": 1e-2, "rtol": 5e-2},
+}
+
+_TENSOR_DTYPES = [infinicore.float16, infinicore.bfloat16, infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for shape, tgt_shape, strides, reduction in _TEST_CASES_DATA:
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 1e-5, "rtol": 1e-4})
+            inp = TensorSpec.from_tensor(shape, strides, dtype)
+            tgt = TensorSpec.from_tensor(tgt_shape, None, dtype)
+
+            kwargs = {}
+            if reduction is not None:
+                kwargs["reduction"] = reduction
+
+            test_cases.append(
+                TestCase(
+                    inputs=[inp, tgt],
+                    kwargs=kwargs,
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description="mse_loss - OUT_OF_PLACE",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """mse_loss operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("mse_loss")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.nn.functional.mse_loss(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.nn.functional.mse_loss(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/msort.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+from framework.utils import is_broadcast
+
+# Test cases format: (shape, input_strides)
+_TEST_CASES_DATA = [
+    ((6, 8), None),
+    ((8, 4), (16, 1)),
+    ((5, 5), None),
+    ((3, 7), (14, 1)),
+    ((10, 3), None),
+    ((2, 16), (32, 1)),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float16: {"atol": 0, "rtol": 1e-3},
+    infinicore.float32: {"atol": 0, "rtol": 1e-5},
+    infinicore.bfloat16: {"atol": 0, "rtol": 1e-2},
+}
+
+_TENSOR_DTYPES = [infinicore.float16, infinicore.bfloat16, infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for data in _TEST_CASES_DATA:
+        shape, in_strides = data
+
+        out_supports_inplace = not is_broadcast(in_strides)
+
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 0, "rtol": 1e-5})
+
+            input_spec = TensorSpec.from_tensor(shape, in_strides, dtype)
+
+            # Out-of-place
+            test_cases.append(
+                TestCase(
+                    inputs=[input_spec],
+                    kwargs={},
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description="msort - OUT_OF_PLACE",
+                )
+            )
+
+            if out_supports_inplace:
+                out_spec = TensorSpec.from_tensor(shape, None, dtype)
+                test_cases.append(
+                    TestCase(
+                        inputs=[input_spec],
+                        kwargs=None,
+                        output_spec=out_spec,
+                        comparison_target="out",
+                        tolerance=tol,
+                        description="msort - INPLACE(out)",
+                    )
+                )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """MSort operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("MSort")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.msort(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.msort(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/multilabel_margin_loss.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+from framework.tensor import TensorInitializer
+
+# Test cases format: (input_shape_N_C, target_shape_N_C, input_strides_or_None, reduction_or_None)
+# infinicore.nn.functional.multilabel_margin_loss(input, target, reduction='mean')
+
+_TEST_CASES_DATA = [
+    ((4, 5), (4, 5), None, None),
+    ((8, 6), (8, 6), None, "sum"),
+    ((1, 3), (1, 3), None, "mean"),
+    ((16, 10), (16, 10), None, None),
+    ((3, 4), (3, 4), None, "none"),
+    ((2, 2), (2, 2), None, None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float32: {"atol": 1e-5, "rtol": 1e-4},
+}
+
+_TENSOR_DTYPES = [infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for inp_shape, tgt_shape, strides, reduction in _TEST_CASES_DATA:
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 1e-5, "rtol": 1e-4})
+            inp = TensorSpec.from_tensor(inp_shape, strides, dtype)
+            tgt = TensorSpec.from_tensor(
+                tgt_shape,
+                None,
+                infinicore.int64,
+                init_mode=TensorInitializer.RANDINT,
+                low=0,
+                high=inp_shape[1],
+            )
+
+            kwargs = {}
+            if reduction is not None:
+                kwargs["reduction"] = reduction
+
+            test_cases.append(
+                TestCase(
+                    inputs=[inp, tgt],
+                    kwargs=kwargs,
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description="multilabel_margin_loss - OUT_OF_PLACE",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """multilabel_margin_loss operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("multilabel_margin_loss")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.nn.functional.multilabel_margin_loss(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.nn.functional.multilabel_margin_loss(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/multilabel_soft_margin_loss.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+
+# Test cases format: (input_shape, target_shape, input_strides_or_None, reduction_or_None)
+# infinicore.nn.functional.multilabel_soft_margin_loss(input, target, reduction='mean')
+
+_TEST_CASES_DATA = [
+    ((4, 5), (4, 5), None, None),
+    ((8, 6), (8, 6), None, "sum"),
+    ((1, 3), (1, 3), None, "mean"),
+    ((16, 10), (16, 10), None, None),
+    ((3, 4), (3, 4), None, "none"),
+    ((2, 2), (2, 2), None, None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float16: {"atol": 1e-2, "rtol": 1e-1},
+    infinicore.float32: {"atol": 1e-5, "rtol": 1e-4},
+    infinicore.bfloat16: {"atol": 1e-2, "rtol": 5e-2},
+}
+
+_TENSOR_DTYPES = [infinicore.float16, infinicore.bfloat16, infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for inp_shape, tgt_shape, strides, reduction in _TEST_CASES_DATA:
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 1e-5, "rtol": 1e-4})
+            inp = TensorSpec.from_tensor(inp_shape, strides, dtype)
+            tgt = TensorSpec.from_tensor(tgt_shape, None, dtype)
+
+            kwargs = {}
+            if reduction is not None:
+                kwargs["reduction"] = reduction
+
+            test_cases.append(
+                TestCase(
+                    inputs=[inp, tgt],
+                    kwargs=kwargs,
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description="multilabel_soft_margin_loss - OUT_OF_PLACE",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """multilabel_soft_margin_loss operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("multilabel_soft_margin_loss")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.nn.functional.multilabel_soft_margin_loss(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.nn.functional.multilabel_soft_margin_loss(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/mv.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+from framework.utils import is_broadcast
+
+# Test cases format: (mat_shape, vec_shape, mat_strides_or_None, vec_strides_or_None)
+# mv(mat, vec, out=None)
+
+_TEST_CASES_DATA = [
+    ((3, 4), (4,), None, None),
+    ((8, 8), (8,), (512, 1), None),
+    ((1, 5), (5,), None, None),
+    ((6, 6), (6,), None, (0,)),
+    ((12, 12), (12,), (144, 12), None),
+    ((16, 8), (8,), None, None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float16: {"atol": 0, "rtol": 1e-2},
+    infinicore.float32: {"atol": 0, "rtol": 1e-3},
+    infinicore.bfloat16: {"atol": 0, "rtol": 5e-2},
+}
+
+_TENSOR_DTYPES = [infinicore.float16, infinicore.bfloat16, infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for m_shape, v_shape, m_strides, v_strides in _TEST_CASES_DATA:
+        out_supports_inplace = not is_broadcast(v_strides)
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 0, "rtol": 1e-3})
+            m = TensorSpec.from_tensor(m_shape, m_strides, dtype)
+            v = TensorSpec.from_tensor(v_shape, v_strides, dtype)
+
+            test_cases.append(
+                TestCase(
+                    inputs=[m, v],
+                    kwargs={},
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description="mv - OUT_OF_PLACE",
+                )
+            )
+
+            if out_supports_inplace:
+                out_spec = TensorSpec.from_tensor((m_shape[0],), None, dtype)
+                test_cases.append(
+                    TestCase(
+                        inputs=[m, v],
+                        kwargs=None,
+                        output_spec=out_spec,
+                        comparison_target="out",
+                        tolerance=tol,
+                        description="mv - INPLACE(out)",
+                    )
+                )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """mv operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("mv")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.mv(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.mv(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/narrow.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+
+# Test cases format: (input_shape, input_strides_or_None, dim, start, length)
+_TEST_CASES_DATA = [
+    ((5, 6), None, 1, 0, 3),
+    ((4, 4), (16, 1), 0, 1, 2),
+    ((3, 5), None, 1, 1, 2),
+    ((2, 6), None, 1, 0, 1),
+    ((6, 3), None, 0, 2, 2),
+    ((4, 7), (28, 1), 1, 1, 3),
+]
+
+_TOLERANCE_MAP = {infinicore.float32: {"atol": 1e-5, "rtol": 1e-4}}
+_TENSOR_DTYPES = [infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for shape, strides, dim, start, length in _TEST_CASES_DATA:
+        input_spec = TensorSpec.from_tensor(shape, strides, infinicore.float32)
+
+        kwargs = {"dim": dim, "start": start, "length": length}
+
+        test_cases.append(
+            TestCase(
+                inputs=[input_spec],
+                kwargs=kwargs,
+                output_spec=None,
+                comparison_target=None,
+                tolerance=_TOLERANCE_MAP[infinicore.float32],
+                description=f"narrow - OUT_OF_PLACE",
+            )
+        )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """Narrow operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("Narrow")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.narrow(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.narrow(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/narrow_copy.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+from framework.utils import is_broadcast
+
+# Test cases format: (input_shape, input_strides_or_None, dim, start, length)
+_TEST_CASES_DATA = [
+    ((5, 6), None, 1, 0, 3),
+    ((4, 4), (16, 1), 0, 1, 2),
+    ((3, 5), None, 1, 1, 2),
+    ((2, 6), None, 1, 0, 1),
+    ((6, 3), None, 0, 2, 2),
+    ((4, 7), (28, 1), 1, 1, 3),
+]
+
+_TOLERANCE_MAP = {infinicore.float32: {"atol": 1e-5, "rtol": 1e-4}}
+_TENSOR_DTYPES = [infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for shape, strides, dim, start, length in _TEST_CASES_DATA:
+        input_spec = TensorSpec.from_tensor(shape, strides, infinicore.float32)
+
+        out_spec = (
+            TensorSpec.from_tensor(
+                (length,)
+                + tuple(s for s in shape if s is not None and s != shape[dim]),
+                None,
+                infinicore.float32,
+            )
+            if False
+            else None
+        )
+        # Above out_spec construction is conservative and not used; we let test framework compare outputs directly.
+
+        kwargs = {"dim": dim, "start": start, "length": length}
+
+        test_cases.append(
+            TestCase(
+                inputs=[input_spec],
+                kwargs=kwargs,
+                output_spec=None,
+                comparison_target=None,
+                tolerance=_TOLERANCE_MAP[infinicore.float32],
+                description=f"narrow_copy - OUT_OF_PLACE",
+            )
+        )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """NarrowCopy operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("NarrowCopy")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.narrow_copy(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.narrow_copy(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/nll_loss.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+from framework.tensor import TensorInitializer
+
+# Test cases format: (input_shape_N_C, target_shape_N, input_strides_or_None, weight_present_bool, ignore_index_or_None)
+# infinicore.nn.functional.nll_loss(input, target, weight=None, ignore_index=-100, reduction='mean')
+
+_TEST_CASES_DATA = [
+    ((4, 5), (4,), None, False, None),
+    ((8, 10), (8,), None, True, -1),
+    ((1, 3), (1,), None, False, None),
+    ((16, 6), (16,), (96, 6), True, None),
+    ((3, 7), (3,), None, False, None),
+    ((2, 2), (2,), None, True, -100),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float16: {"atol": 1e-3, "rtol": 1e-2},
+    infinicore.float32: {"atol": 1e-5, "rtol": 1e-4},
+    infinicore.bfloat16: {"atol": 1e-2, "rtol": 5e-2},
+}
+
+_TENSOR_DTYPES = [infinicore.float16, infinicore.bfloat16, infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for (
+        logits_shape,
+        target_shape,
+        logits_strides,
+        weight_present,
+        ignore_index,
+    ) in _TEST_CASES_DATA:
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 1e-5, "rtol": 1e-4})
+            logits = TensorSpec.from_tensor(logits_shape, logits_strides, dtype)
+            target = TensorSpec.from_tensor(target_shape, None, infinicore.int64)
+            target = TensorSpec.from_tensor(
+                target_shape,
+                None,
+                infinicore.int64,
+                init_mode=TensorInitializer.RANDINT,
+                low=0,
+                high=logits_shape[
+                    1
+                ],  # high 是 exclusive 上限 => 0 ≤ target < num_classes
+            )
+
+            inputs = [logits, target]
+            kwargs = {}
+            if weight_present:
+                weight_spec = TensorSpec.from_tensor((logits_shape[1],), None, dtype)
+                inputs.append(weight_spec)
+            if ignore_index is not None:
+                kwargs["ignore_index"] = ignore_index
+
+            test_cases.append(
+                TestCase(
+                    inputs=inputs,
+                    kwargs=kwargs,
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description="nll_loss - OUT_OF_PLACE",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """nll_loss operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("nll_loss")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.nn.functional.nll_loss(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.nn.functional.nll_loss(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/nonzero.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+
+# Test cases format: (input_shape, input_strides_or_None)
+# nonzero returns indices of non-zero elements; output is N x ndim indices
+_TEST_CASES_DATA = [
+    ((3, 4), None),
+    ((5,), None),
+    ((2, 2, 3), (12, 6, 2)),
+    ((1, 6), None),
+    ((4, 4), None),
+    ((2, 3, 2), None),
+]
+
+_TOLERANCE_MAP = {infinicore.int64: {"atol": 0, "rtol": 0}}
+_TENSOR_DTYPES = [infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for shape, strides in _TEST_CASES_DATA:
+        input_spec = TensorSpec.from_tensor(shape, strides, infinicore.float32)
+
+        test_cases.append(
+            TestCase(
+                inputs=[input_spec],
+                kwargs={},
+                output_spec=None,
+                comparison_target=None,
+                tolerance=_TOLERANCE_MAP[infinicore.int64],
+                description=f"nonzero - OUT_OF_PLACE",
+            )
+        )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """NonZero operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("NonZero")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.nonzero(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.nonzero(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/normalize.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+
+# Test cases format: (input_shape, input_strides_or_None, p_or_None, dim_or_None, eps_or_None)
+# infinicore.nn.functional.normalize(input, p=2.0, dim=1, eps=1e-12)
+
+_TEST_CASES_DATA = [
+    ((4, 3), None, None, None, None),
+    ((8, 5), (40, 5), 1.0, 1, 1e-12),
+    ((1, 10), None, 2.0, 1, 1e-6),
+    ((16, 100), None, float("inf"), 1, None),
+    ((3, 7), None, 0.5, 1, None),
+    ((2, 2), None, None, 0, None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float16: {"atol": 1e-3, "rtol": 1e-2},
+    infinicore.float32: {"atol": 1e-5, "rtol": 1e-4},
+    infinicore.bfloat16: {"atol": 1e-2, "rtol": 5e-2},
+}
+
+_TENSOR_DTYPES = [infinicore.float16, infinicore.bfloat16, infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for shape, strides, p, dim, eps in _TEST_CASES_DATA:
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 1e-5, "rtol": 1e-4})
+            inp = TensorSpec.from_tensor(shape, strides, dtype)
+
+            kwargs = {}
+            if p is not None:
+                kwargs["p"] = p
+            if dim is not None:
+                kwargs["dim"] = dim
+            if eps is not None:
+                kwargs["eps"] = eps
+
+            test_cases.append(
+                TestCase(
+                    inputs=[inp],
+                    kwargs=kwargs,
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description="normalize - OUT_OF_PLACE",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """normalize operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("normalize")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.nn.functional.normalize(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.nn.functional.normalize(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/one_hot.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.tensor import TensorInitializer
+from framework.runner import GenericTestRunner
+
+# Test cases format: (indices_shape, indices_strides_or_None, num_classes_or_None)
+_TEST_CASES_DATA = [
+    ((5,), None, 10),
+    ((3, 4), None, 8),
+    ((2, 2), None, None),
+    ((1,), None, 3),
+    ((6,), None, 6),
+    ((4, 3), None, 12),
+]
+
+_TOLERANCE_MAP = {infinicore.int64: {"atol": 0, "rtol": 0}}
+_TENSOR_DTYPES = [infinicore.int64]
+
+
+def parse_test_cases():
+    test_cases = []
+    for shape, strides, num_classes in _TEST_CASES_DATA:
+        # ensure indices are non-negative and within [0, num_classes) when provided
+        if num_classes is not None:
+            high = num_classes
+        else:
+            high = max(1, shape[0])
+        idx_spec = TensorSpec.from_tensor(
+            shape,
+            strides,
+            infinicore.int64,
+            init_mode=TensorInitializer.RANDINT,
+            low=0,
+            high=high,
+        )
+
+        kwargs = {}
+        if num_classes is not None:
+            kwargs["num_classes"] = num_classes
+
+        out_spec = None
+
+        test_cases.append(
+            TestCase(
+                inputs=[idx_spec],
+                kwargs=kwargs,
+                output_spec=out_spec,
+                comparison_target=None,
+                tolerance=_TOLERANCE_MAP.get(infinicore.int64),
+                description=f"one_hot - OUT_OF_PLACE",
+            )
+        )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """OneHot operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("OneHot")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.nn.functional.one_hot(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.nn.functional.one_hot(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/pad.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+from framework.utils import is_broadcast
+
+# Test cases format: (shape, pad_tuple, mode, value_or_None, input_strides_or_None)
+# infinicore.nn.functional.pad(input, pad, mode='constant', value=0)
+
+_TEST_CASES_DATA = [
+    ((1, 3, 4, 4), (1, 1, 2, 2), "constant", 0.0, None),
+    ((2, 3, 8, 8), (2, 2, 2, 2), "reflect", None, (384, 128, 16, 1)),
+    ((1, 1, 10), (3, 3), "replicate", None, None),
+    ((2, 3, 6, 6), (1, 0, 1, 0), "constant", 1.5, None),
+    ((3, 4, 5), (2, 2, 1, 1), "circular", None, None),
+    ((4, 5), (1, 2), "constant", -1.0, None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float16: {"atol": 1e-2, "rtol": 1e-2},
+    infinicore.float32: {"atol": 1e-5, "rtol": 1e-4},
+    infinicore.bfloat16: {"atol": 1e-2, "rtol": 5e-2},
+}
+
+_TENSOR_DTYPES = [infinicore.float16, infinicore.bfloat16, infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for data in _TEST_CASES_DATA:
+        shape, pad_t, mode, value, in_strides = data
+
+        supports_inplace = not is_broadcast(in_strides)
+
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 1e-5, "rtol": 1e-4})
+            in_spec = TensorSpec.from_tensor(shape, in_strides, dtype)
+
+            kwargs = {"pad": pad_t, "mode": mode}
+            if value is not None:
+                kwargs["value"] = value
+
+            test_cases.append(
+                TestCase(
+                    inputs=[in_spec],
+                    kwargs=kwargs,
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description=f"pad - OUT_OF_PLACE",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """Pad operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("Pad")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.nn.functional.pad(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.nn.functional.pad(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/pairwise_distance.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+from framework.utils import is_broadcast
+
+# Test cases format: (shape, p, eps, keepdim, a_strides_or_None, b_strides_or_None)
+# infinicore.nn.functional.pairwise_distance(x1, x2, p=2.0, eps=1e-6, keepdim=False)
+
+_TEST_CASES_DATA = [
+    ((8, 16), 2.0, 1e-6, False, None, None),
+    ((8, 16), 1.0, 1e-6, False, (128, 1), (128, 1)),
+    ((2, 3, 4), 2.0, 1e-6, True, None, None),
+    ((16, 64), 3.0, 1e-6, False, None, None),
+    ((4, 5, 6), 2.0, 1e-6, False, None, None),
+    ((3, 4, 5), 2.0, 1e-6, True, (60, 20, 4), None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float16: {"atol": 1e-2, "rtol": 1e-2},
+    infinicore.float32: {"atol": 1e-5, "rtol": 1e-4},
+    infinicore.bfloat16: {"atol": 1e-2, "rtol": 5e-2},
+}
+
+_TENSOR_DTYPES = [infinicore.float16, infinicore.bfloat16, infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for data in _TEST_CASES_DATA:
+        shape, p, eps, keepdim = data[0], data[1], data[2], data[3]
+        a_strides = data[4] if len(data) > 4 else None
+        b_strides = data[5] if len(data) > 5 else None
+
+        a_supports_inplace = not is_broadcast(a_strides)
+        b_supports_inplace = not is_broadcast(b_strides)
+
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 1e-5, "rtol": 1e-4})
+            a_spec = TensorSpec.from_tensor(shape, a_strides, dtype)
+            b_spec = TensorSpec.from_tensor(shape, b_strides, dtype)
+
+            kwargs = {"p": p, "eps": eps, "keepdim": keepdim}
+
+            test_cases.append(
+                TestCase(
+                    inputs=[a_spec, b_spec],
+                    kwargs=kwargs,
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description=f"pairwise_distance - OUT_OF_PLACE",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """PairwiseDistance operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("PairwiseDistance")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.nn.functional.pairwise_distance(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.nn.functional.pairwise_distance(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/pdist.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+from framework.utils import is_broadcast
+
+# Test cases format: (shape, p, a_strides_or_None)
+# infinicore.pdist(input, p=2.0) computes pairwise distances between rows of input
+
+_TEST_CASES_DATA = [
+    ((8, 16), 2.0, None),
+    ((10, 5), 2.0, (80, 8)),
+    ((4, 3), 1.0, None),
+    ((6, 8), 3.0, None),
+    ((2, 16), 2.0, None),
+    ((12, 4), 2.0, None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float32: {"atol": 1e-5, "rtol": 1e-4},
+}
+
+_TENSOR_DTYPES = [infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for data in _TEST_CASES_DATA:
+        shape, p = data[0], data[1]
+        in_strides = data[2] if len(data) > 2 else None
+
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 1e-5, "rtol": 1e-4})
+            input_spec = TensorSpec.from_tensor(shape, in_strides, dtype)
+
+            kwargs = {"p": p}
+            test_cases.append(
+                TestCase(
+                    inputs=[input_spec],
+                    kwargs=kwargs,
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description=f"pdist - OUT_OF_PLACE",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """Pdist operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("Pdist")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.pdist(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.pdist(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/pixel_shuffle.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+from framework.utils import is_broadcast
+
+# Test cases format: (shape, upscale_factor, input_strides_or_None)
+# infinicore.nn.functional.pixel_shuffle(input, upscale_factor)
+
+_TEST_CASES_DATA = [
+    ((1, 4, 8, 8), 2, None),
+    ((2, 9, 4, 4), 3, (288, 144, 36, 9)),
+    ((1, 16, 4, 4), 4, None),
+    ((3, 8, 6, 6), 2, None),
+    ((2, 12, 3, 3), 2, None),
+    ((4, 27, 2, 2), 3, None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float16: {"atol": 1e-2, "rtol": 1e-2},
+    infinicore.float32: {"atol": 1e-5, "rtol": 1e-4},
+    infinicore.bfloat16: {"atol": 1e-2, "rtol": 5e-2},
+}
+
+_TENSOR_DTYPES = [infinicore.float16, infinicore.bfloat16, infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for data in _TEST_CASES_DATA:
+        shape, factor = data[0], data[1]
+        in_strides = data[2] if len(data) > 2 else None
+
+        supports_inplace = not is_broadcast(in_strides)
+
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 1e-5, "rtol": 1e-4})
+            in_spec = TensorSpec.from_tensor(shape, in_strides, dtype)
+
+            kwargs = {"upscale_factor": factor}
+            test_cases.append(
+                TestCase(
+                    inputs=[in_spec],
+                    kwargs=kwargs,
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description=f"pixel_shuffle - OUT_OF_PLACE",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """PixelShuffle operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("PixelShuffle")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.nn.functional.pixel_shuffle(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.nn.functional.pixel_shuffle(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/pixel_unshuffle.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+from framework.utils import is_broadcast
+
+# Test cases format: (shape, downscale_factor, input_strides_or_None)
+# infinicore.nn.functional.pixel_unshuffle(input, downscale_factor)
+
+_TEST_CASES_DATA = [
+    ((1, 4, 8, 8), 2, None),
+    ((2, 9, 6, 6), 3, (648, 72, 12, 2)),
+    ((1, 16, 4, 4), 4, None),
+    ((3, 8, 6, 6), 2, None),
+    ((2, 12, 4, 4), 2, None),
+    ((4, 27, 6, 6), 3, None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float16: {"atol": 1e-2, "rtol": 1e-2},
+    infinicore.float32: {"atol": 1e-5, "rtol": 1e-4},
+    infinicore.bfloat16: {"atol": 1e-2, "rtol": 5e-2},
+}
+
+_TENSOR_DTYPES = [infinicore.float16, infinicore.bfloat16, infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for data in _TEST_CASES_DATA:
+        shape, factor = data[0], data[1]
+        in_strides = data[2] if len(data) > 2 else None
+
+        supports_inplace = not is_broadcast(in_strides)
+
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 1e-5, "rtol": 1e-4})
+            in_spec = TensorSpec.from_tensor(shape, in_strides, dtype)
+
+            kwargs = {"downscale_factor": factor}
+            test_cases.append(
+                TestCase(
+                    inputs=[in_spec],
+                    kwargs=kwargs,
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description=f"pixel_unshuffle - OUT_OF_PLACE",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """PixelUnshuffle operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("PixelUnshuffle")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.nn.functional.pixel_unshuffle(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.nn.functional.pixel_unshuffle(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/prelu.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+from framework.utils import is_broadcast
+
+# Test cases format: (in_shape, in_strides_or_None, weight_shape_or_None)
+# Note: PReLU requires a weight parameter of shape (C,) or (1,), we create a per-channel weight when possible.
+
+_TEST_CASES_DATA = [
+    ((4, 4), None, None),
+    ((8, 4, 4), (128, 32, 1), (4,)),
+    ((2, 3, 6), None, (3,)),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float16: {"atol": 1e-3, "rtol": 1e-2},
+    infinicore.float32: {"atol": 1e-5, "rtol": 1e-4},
+    infinicore.bfloat16: {"atol": 1e-2, "rtol": 5e-2},
+}
+
+_TENSOR_DTYPES = [infinicore.float16, infinicore.bfloat16, infinicore.float32]
+
+
+def parse_test_cases():
+    """prelu(input, weight)"""
+    test_cases = []
+
+    for data in _TEST_CASES_DATA:
+        shape = data[0]
+        in_strides = data[1] if len(data) > 1 else None
+        weight_shape = data[2] if len(data) > 2 and data[2] is not None else None
+
+        for dtype in _TENSOR_DTYPES:
+            tolerance = _TOLERANCE_MAP.get(dtype, {"atol": 1e-5, "rtol": 1e-4})
+
+            input_spec = TensorSpec.from_tensor(shape, in_strides, dtype)
+
+            # Determine default weight shape: channel dimension if available
+            if weight_shape is None:
+                if len(shape) >= 2:
+                    c = shape[1]
+                    weight_spec = TensorSpec.from_tensor((c,), None, dtype)
+                else:
+                    weight_spec = TensorSpec.from_tensor((1,), None, dtype)
+            else:
+                weight_spec = TensorSpec.from_tensor(weight_shape, None, dtype)
+
+            test_cases.append(
+                TestCase(
+                    inputs=[input_spec, weight_spec],
+                    kwargs={},
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tolerance,
+                    description=f"PReLU - OUT_OF_PLACE",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """PReLU operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("PReLU")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.nn.functional.prelu(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.nn.functional.prelu(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/prod.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+from framework.utils import is_broadcast
+
+# Test cases format: (in_shape, in_strides_or_None, dim_or_None, keepdim_or_None, dtype_or_None)
+# prod computes product along dim(s) or overall
+
+_TEST_CASES_DATA = [
+    ((8, 8), None, None, None, None),
+    ((8, 8), (16, 1), 1, False, None),
+    ((2, 3, 4), None, 0, True, None),
+    ((1, 8), None, 0, False, None),
+    ((16, 64), (128, 1), None, None, None),
+    ((4, 5, 6), (60, 12, 2), 2, True, None),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float16: {"atol": 1e-3, "rtol": 1e-2},
+    infinicore.float32: {"atol": 1e-5, "rtol": 1e-4},
+}
+
+_TENSOR_DTYPES = [infinicore.float16, infinicore.float32]
+
+
+def parse_test_cases():
+    test_cases = []
+    for data in _TEST_CASES_DATA:
+        shape, strides, dim, keepdim, dtype_param = data
+
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 1e-5, "rtol": 1e-3})
+            in_spec = TensorSpec.from_tensor(shape, strides, dtype)
+
+            kwargs = {}
+            if dim is not None:
+                kwargs["dim"] = dim
+            if keepdim is not None:
+                kwargs["keepdim"] = keepdim
+            if dtype_param is not None:
+                kwargs["dtype"] = dtype_param
+
+            test_cases.append(
+                TestCase(
+                    inputs=[in_spec],
+                    kwargs=kwargs,
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description="Prod - OUT_OF_PLACE",
+                )
+            )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """Prod operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("Prod")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.prod(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.prod(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/quantile.py

+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+import torch
+import infinicore
+from framework.base import BaseOperatorTest, TensorSpec, TestCase
+from framework.runner import GenericTestRunner
+from framework.utils import is_broadcast
+
+# Test cases format: (in_shape, in_strides_or_None, q_or_None, dim_or_None, keepdim_or_None, out_strides_or_None)
+# quantile computes quantiles along dim or overall. q may be float or tensor
+
+_TEST_CASES_DATA = [
+    ((8, 8), None, 0.5, None, None, None),
+    ((8, 8), (16, 1), 0.25, 1, False, None),
+    ((2, 3, 4), None, 0.75, 2, True, (0, 1, 1)),
+    ((16, 64), (128, 1), 0.5, None, None, None),
+    ((4, 5, 6), (60, 12, 2), 0.5, 2, True, (12, 4, 1)),
+]
+
+_TOLERANCE_MAP = {
+    infinicore.float32: {"atol": 1e-5, "rtol": 1e-4},
+}
+
+_TENSOR_DTYPES = [infinicore.float32]
+
+
+def _compute_out_shape(shape, dim, keepdim, q_is_tensor=False):
+    # if q is tensor with len>1, output shape may include q dim; keep simple: when q is tensor, return (len(q), ...) prefix
+    if dim is None:
+        base = ()
+    else:
+        if isinstance(dim, tuple):
+            dims = sorted([(d if d >= 0 else len(shape) + d) for d in dim])
+        else:
+            dims = [dim]
+        if keepdim:
+            out = list(shape)
+            for d in dims:
+                out[d] = 1
+            base = tuple(out)
+        else:
+            base = tuple(s for i, s in enumerate(shape) if i not in dims)
+
+    if q_is_tensor:
+        # Prepend q-length as first dim
+        return (2,) + base
+    return base
+
+
+def parse_test_cases():
+    test_cases = []
+    for data in _TEST_CASES_DATA:
+        shape, strides, q, dim, keepdim, out_strides = data
+        q_is_tensor = isinstance(q, torch.Tensor)
+        out_supports_inplace = not is_broadcast(out_strides)
+
+        for dtype in _TENSOR_DTYPES:
+            tol = _TOLERANCE_MAP.get(dtype, {"atol": 1e-5, "rtol": 1e-3})
+            in_spec = TensorSpec.from_tensor(shape, strides, dtype)
+
+            kwargs = {"q": q}
+            if dim is not None:
+                kwargs["dim"] = dim
+            if keepdim is not None:
+                kwargs["keepdim"] = keepdim
+
+            test_cases.append(
+                TestCase(
+                    inputs=[in_spec],
+                    kwargs=kwargs,
+                    output_spec=None,
+                    comparison_target=None,
+                    tolerance=tol,
+                    description="Quantile - OUT_OF_PLACE",
+                )
+            )
+
+            out_shape = _compute_out_shape(shape, dim, keepdim, q_is_tensor=q_is_tensor)
+            out_spec = TensorSpec.from_tensor(out_shape, out_strides, dtype)
+            if out_supports_inplace:
+                test_cases.append(
+                    TestCase(
+                        inputs=[in_spec],
+                        kwargs=kwargs,
+                        output_spec=out_spec,
+                        comparison_target="out",
+                        tolerance=tol,
+                        description="Quantile - INPLACE(out)",
+                    )
+                )
+
+    return test_cases
+
+
+class OpTest(BaseOperatorTest):
+    """Quantile operator test with simplified implementation"""
+
+    def __init__(self):
+        super().__init__("Quantile")
+
+    def get_test_cases(self):
+        return parse_test_cases()
+
+    def torch_operator(self, *args, **kwargs):
+        return torch.quantile(*args, **kwargs)
+
+    # def infinicore_operator(self, *args, **kwargs):
+    #     """InfiniCore implementation (operator not yet available)."""
+    #     return infinicore.quantile(*args, **kwargs)
+
+
+def main():
+    """Main entry point"""
+    runner = GenericTestRunner(OpTest)
+    runner.run_and_exit()
+
+
+if __name__ == "__main__":
+    main()

test/infinicore/ops/random_sample.py

@@ -80,7 +80,7 @@ def parse_test_cases():
                     ),
                     comparison_target="out",
                     tolerance=tolerance,
-                    description=f"RandomSample - OUT",
+                    description=f"RandomSample - INPLACE(out)",
                 )
             )