[重构V] 修改命名空间、重定向 Operators、文件头引用、更好的统一格式化

include/axono/core/module.h

@@ -1,6 +1,10 @@
+#pragma once
+
 #include "tensor.h"
 
-namespace axono::core {
+namespace axono {
+namespace core {
+
 class Module {
 private:
     std::unordered_map<std::string, Tensor> weights_;  // 存储权重张量
@@ -13,4 +17,6 @@ class Module {
     }
     auto& weights() { return weights_; }
 };
-}
+
+} // namespace core
+} // namespace axono

include/axono/core/ops.h

@@ -54,5 +54,6 @@ class OpRegistry {
     }; \
     static RegisterOp_##name register_op_##name; \
     pybind11::object op_impl_##name(const pybind11::args& args)
+
 } // namespace core
 } // namespace axono

include/axono/core/tensor.h

@@ -14,6 +14,7 @@
 // 遵循 lib, type
 namespace axono {
 namespace core {
+
 class Tensor {
  public:
   // 构造函数
@@ -103,5 +104,6 @@ class Tensor {
   // 初始化数据存储
   void InitializeStorage();
 };
+
 }  // namespace core
 }  // namespace axono

include/axono/compute/cpu/operators/add.h → include/axono/ops/cpu/add.h

@@ -1,11 +1,12 @@
+#pragma once
+
 #include "axono/core/macros.h"
 #include "axono/core/tensor.h"
 #include "axono/core/types.h"
 
 namespace axono {
-namespace compute {
+namespace ops {
 namespace cpu {
-namespace operators {
 
 AXONO_EXPORT core::Status Add(const core::Context &ctx, const core::Tensor &a,
                               const core::Tensor &b, core::Tensor &result);
@@ -14,7 +15,6 @@ AXONO_EXPORT core::Status AddScalar(const core::Context &ctx,
                                     const core::Tensor &a, void *scalar,
                                     size_t scalar_size, core::Tensor &result);
 
-}  // namespace operators
 }  // namespace cpu
-}  // namespace compute
+}  // namespace ops
 }  // namespace axono

include/axono/compute/cpu/operators/matmul.h → include/axono/ops/cpu/matmul.h

@@ -6,14 +6,12 @@
 #include "axono/core/tensor.h"
 
 namespace axono {
-namespace compute {
+namespace ops {
 namespace cpu {
-namespace operators {
 
 core::Status MatMul(const core::Context &ctx, const core::Tensor &a,
                     const core::Tensor &b, core::Tensor &result);
 
-}  // namespace operators
 }  // namespace cpu
-}  // namespace compute
+}  // namespace ops
 }  // namespace axono

include/axono/compute/cuda/operators/randn.h → include/axono/ops/cpu/randn.h

@@ -1,10 +1,15 @@
 #pragma once
+
 #include "axono/core/tensor.h"
 #include "axono/core/types.h"
 
-namespace axono::compute::cuda::operators {
+namespace axono {
+namespace ops {
+namespace cpu {
 
 core::Status Randn(const core::Context& ctx, core::Tensor& out,
                    float mean = 0.0f, float stddev = 1.0f);
 
-}  // namespace axono::compute::cuda::operators
+}  // namespace cpu
+}  // namespace ops
+}  // namespace axono

include/axono/compute/cpu/ops/relu.h → include/axono/ops/cpu/relu.h

@@ -1,19 +1,19 @@
+#pragma once
+
 #include "axono/core/macros.h"
 #include "axono/core/tensor.h"
 #include "axono/core/types.h"
 
 namespace axono {
-namespace compute {
-namespace cpu {
 namespace ops {
+namespace cpu {
 
 core::Status DispatchRelu(const core::Tensor &input, core::Tensor &output);
 core::Status DispatchReluInplace(core::Tensor &tensor);
 core::Status Relu(const core::Context &ctx, const core::Tensor &input,
                   core::Tensor &output);
 core::Status ReluInplace(const core::Context &ctx, core::Tensor &tensor);
 
-}  // namespace ops
 }  // namespace cpu
-}  // namespace compute
+}  // namespace ops
 }  // namespace axono

include/axono/compute/cuda/operators/add.h → include/axono/ops/cuda/add.h

@@ -1,11 +1,12 @@
+#pragma once
+
 #include "axono/core/macros.h"
 #include "axono/core/tensor.h"
 #include "axono/core/types.h"
 
 namespace axono {
-namespace compute {
+namespace ops {
 namespace cuda {
-namespace operators {
 
 AXONO_EXPORT core::Status Add(const core::Context &ctx, const core::Tensor &a,
                               const core::Tensor &b, core::Tensor &result);
@@ -14,7 +15,6 @@ AXONO_EXPORT core::Status AddScalar(const core::Context &ctx,
                                     const core::Tensor &a, void *scalar,
                                     size_t scalar_size, core::Tensor &result);
 
-}  // namespace operators
 }  // namespace cuda
-}  // namespace compute
+}  // namespace ops
 }  // namespace axono

include/axono/compute/cuda/operators/matmul.h → include/axono/ops/cuda/matmul.h

@@ -1,16 +1,17 @@
+#pragma once
+
+#include <cstddef>
+
 #include "axono/core/macros.h"
 #include "axono/core/tensor.h"
-#include "axono/core/types.h"
 
 namespace axono {
-namespace compute {
+namespace ops {
 namespace cuda {
-namespace operators {
 
 core::Status MatMul(const core::Context &ctx, const core::Tensor &a,
                     const core::Tensor &b, core::Tensor &result);
 
-}
 }  // namespace cuda
-}  // namespace compute
+}  // namespace ops
 }  // namespace axono

include/axono/compute/cpu/operators/randn.h → include/axono/ops/cuda/randn.h

@@ -1,10 +1,15 @@
 #pragma once
+
 #include "axono/core/tensor.h"
 #include "axono/core/types.h"
 
-namespace axono::compute::cpu::operators {
+namespace axono {
+namespace ops {
+namespace cuda {
 
 core::Status Randn(const core::Context& ctx, core::Tensor& out,
                    float mean = 0.0f, float stddev = 1.0f);
 
-}  // namespace axono::compute::cpu::operators
+}  // namespace cuda
+}  // namespace ops
+}  // namespace axono

include/axono/compute/cuda/ops/relu.h → include/axono/ops/cuda/relu.h

@@ -1,19 +1,19 @@
+#pragma once
+
 #include "axono/core/macros.h"
 #include "axono/core/tensor.h"
 #include "axono/core/types.h"
 
 namespace axono {
-namespace compute {
-namespace cuda {
 namespace ops {
+namespace cuda {
 
 core::Status DispatchRelu(const core::Tensor &input, core::Tensor &output);
 core::Status DispatchReluInplace(core::Tensor &tensor);
 core::Status Relu(const core::Context &ctx, const core::Tensor &input,
                   core::Tensor &output);
 core::Status ReluInplace(const core::Context &ctx, core::Tensor &tensor);
 
-}  // namespace ops
 }  // namespace cuda
-}  // namespace compute
+}  // namespace ops
 }  // namespace axono

include/axono/pybind/compute/operators/add.h → include/axono/pybind/ops/add.h

@@ -1,17 +1,16 @@
 #include <pybind11/pybind11.h>
 
-namespace py = pybind11;
-
 #include "axono/core/ops.h"
 
 #ifdef COMPILED_WITH_CUDA
-#include "axono/compute/cuda/operators/add.h"
+#include "axono/ops/cuda/add.h"
 #endif
-#include "axono/compute/cpu/operators/add.h"
+#include "axono/ops/cpu/add.h"
+
+namespace py = pybind11;
 
 namespace axono {
-namespace compute {
-namespace operators {
+namespace ops {
 
 py::object op_impl_add(const py::args& args);
 py::object op_impl_add_scalar(const py::args& args);
@@ -27,10 +26,10 @@ REGISTER_OP(add) {
     core::Status status;
     if (a.is_cuda()) {
 #ifdef COMPILED_WITH_CUDA
-        status = cuda::operators::Add(ctx, a, b, result);
+        status = cuda::Add(ctx, a, b, result);
 #endif
     } else {
-        status = cpu::operators::Add(ctx, a, b, result);
+        status = cpu::Add(ctx, a, b, result);
     }
     if (status != core::Status::OK)
         throw std::runtime_error("执行 add 时出现问题，错误代码：" + std::to_string(static_cast<int>(status)));
@@ -51,10 +50,10 @@ REGISTER_OP(add_scalar) {
         float value = scalar.cast<float>();
         if (a.is_cuda()){
 #ifdef COMPILED_WITH_CUDA
-            status = cuda::operators::AddScalar(ctx, a, &value, sizeof(float), result);
+            status = cuda::AddScalar(ctx, a, &value, sizeof(float), result);
 #endif
         } else {
-            status = cpu::operators::AddScalar(ctx, a, &value, sizeof(float), result);
+            status = cpu::AddScalar(ctx, a, &value, sizeof(float), result);
         }
     }
     if (status != core::Status::OK) {
@@ -63,10 +62,10 @@ REGISTER_OP(add_scalar) {
         int32_t value = scalar.cast<int32_t>();
         if (a.is_cuda()) {
 #ifdef COMPILED_WITH_CUDA
-            status = cuda::operators::AddScalar(ctx, a, &value, sizeof(int32_t), result);
+            status = cuda::AddScalar(ctx, a, &value, sizeof(int32_t), result);
 #endif
         } else {
-            status = cpu::operators::AddScalar(ctx, a, &value, sizeof(int32_t), result);
+            status = cpu::AddScalar(ctx, a, &value, sizeof(int32_t), result);
         }
 
         if (status != core::Status::OK)
@@ -78,6 +77,5 @@ REGISTER_OP(add_scalar) {
     return pybind11::cast(result);
 }
 
-}
-}
-}
+} // namespace ops
+} // namespace axono

include/axono/pybind/compute/operators/matmul.h → include/axono/pybind/ops/matmul.h

@@ -1,15 +1,14 @@
 #include <pybind11/pybind11.h>
 
-namespace py = pybind11;
-
 #ifdef COMPILED_WITH_CUDA
-#include "axono/compute/cuda/operators/matmul.h"
+#include "axono/ops/cuda/matmul.h"
 #endif
-#include "axono/compute/cpu/operators/matmul.h"
+#include "axono/ops/cpu/matmul.h"
+
+namespace py = pybind11;
 
 namespace axono {
-namespace compute {
-namespace operators {
+namespace ops {
 
 py::object op_impl_matmul(const py::args& args);
 
@@ -19,26 +18,23 @@ REGISTER_OP(matmul) {
     }
     auto& a = pybind11::cast<core::Tensor&>(args[0]);
     auto& b = pybind11::cast<core::Tensor&>(args[1]);
+    size_t m = a.shape()[0];
+    size_t n = b.shape()[1];
     core::Context ctx;
-    core::Tensor result;
     core::Status status;
-
+    core::Tensor result = core::Tensor(a.dtype(), std::vector<size_t>{m, n}, a.device());;
     if (a.is_cuda()) {
 #ifdef COMPILED_WITH_CUDA
-        size_t m = a.shape()[0];
-        size_t n = b.shape()[1];
-        auto result = core::Tensor(a.dtype(), std::vector<size_t>{m, n}, a.device());
-        status = cuda::operators::MatMul(ctx, a, b, result);
+        status = cuda::MatMul(ctx, a, b, result);
 #endif
     } else {
-        status = compute::cpu::operators::MatMul(ctx, a, b, result);
+        status = cpu::MatMul(ctx, a, b, result);
     }
     if (status != core::Status::OK)
         throw std::runtime_error("执行 Matmul 时出现问题，错误代码：" + std::to_string(static_cast<int>(status)));
 
     return pybind11::cast(result);
 }
 
-}
-}
-}
+} // namespace ops
+} // namespace axono