PREScode
/
uc-modern-cpp-student
Not watched
1
0
Fork 0
Code
Releases 0 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 8987d662ae
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8987d662ae'
${ noResults }
uc-modern-cpp-student/cc/uctc.cc

118 lines
6.5 kB
Raw Blame History 

  1. #include <pybind11/pybind11.h>

  2. #include <pybind11/stl.h>

  3. #include "math/arith.h"

  4. #include "operators/nn.h"

  5. #include "tensor/tensor.h"

  6. #include "operators/ops.h"

  7. #include "operators/autodiff.h"

  8. 

  9. namespace py = pybind11;

  10. 

  11. PYBIND11_MODULE(uctc, m) {

  12. 

  13.     py::module C = m.def_submodule("C", "C module");

  14. 

  15.     py::module arith = C.def_submodule("arith", "Arithmetic module");

  16.     arith.def("sqrt", &arith::sqrt, "Square root function", py::arg("x") = 0.0);

  17. 

  18.     py::class_<tensor::Tensor, std::shared_ptr<tensor::Tensor>>(m, "Tensor")

  19.     .def_readonly("shape", &tensor::Tensor::shape)

  20.     .def_readonly("size", &tensor::Tensor::size)

  21.     .def("data", &tensor::Tensor::get_data, "Get the data of the tensor", pybind11::return_value_policy::copy)

  22.     .def("transpose", &tensor::Tensor::transpose, "Transpose the tensor", pybind11::return_value_policy::copy);

  23.     

  24.     py::module nn = m.def_submodule("nn", "Neural network module");

  25.     py::class_<nn::Node, std::shared_ptr<nn::Node>>(nn, "Node")

  26.     .def("data", &nn::Node::get_data, "Get the data of the node", pybind11::return_value_policy::copy)

  27.     .def("tensor", &nn::Node::get_tensor, "Get the tensor of the node", pybind11::return_value_policy::automatic_reference);

  28. 

  29.     py::class_<nn::DataNode, nn::Node, std::shared_ptr<nn::DataNode>>(nn, "DataNode");

  30. 

  31.     py::class_<nn::Parameter, nn::DataNode, std::shared_ptr<nn::Parameter>>(nn, "Parameter")

  32.     .def(pybind11::init<py::array_t<float>>(), "Create a parameter from an array.")

  33.     .def("update", &nn::Parameter::update, "Update the parameter node", py::arg("grad") = nullptr, py::arg("learning_rate") = 0.001);

  34. 

  35.     py::class_<nn::Constant, nn::DataNode, std::shared_ptr<nn::Constant>>(nn, "Constant")

  36.     .def(pybind11::init<py::array_t<float>>(), "Create a constant node from a numpy array");

  37. 

  38.     py::class_<nn::FunctionNode, nn::Node, std::shared_ptr<nn::FunctionNode>>(nn, "FunctionNode");

  39. 

  40.     py::class_<nn::Add, nn::FunctionNode, std::shared_ptr<nn::Add>>(nn, "Add")

  41.     .def(py::init<std::shared_ptr<nn::Node>, std::shared_ptr<nn::Node>>(), "Create an add function node")

  42.     .def("forward", &nn::Add::forward, "Forward function");

  43. 

  44.     py::class_<nn::AddBias, nn::FunctionNode, std::shared_ptr<nn::AddBias>>(nn, "AddBias")

  45.     .def(py::init<std::shared_ptr<nn::Node>, std::shared_ptr<nn::Node>>(), "Create an add bias function node")

  46.     .def("forward", &nn::AddBias::forward, "Forward function")

  47.     .def("data", &nn::AddBias::get_data, "Get the data of the node", pybind11::return_value_policy::automatic_reference);

  48. 

  49.     py::class_<nn::Linear, nn::FunctionNode, std::shared_ptr<nn::Linear>>(nn, "Linear")

  50.     .def(py::init<std::shared_ptr<nn::Node>, std::shared_ptr<nn::Node>>(), "Create a linear function node")

  51.     .def("forward", &nn::Linear::forward, "Forward function");

  52. 

  53.     py::class_<nn::ReLU, nn::FunctionNode, std::shared_ptr<nn::ReLU>>(nn, "ReLU")

  54.     .def(py::init<std::shared_ptr<nn::Node>>(), "Create a ReLU function node");

  55. 

  56.     py::class_<nn::Loss, nn::FunctionNode, std::shared_ptr<nn::Loss>>(nn, "Loss");

  57. 

  58.     py::class_<nn::SquareLoss, nn::Loss, std::shared_ptr<nn::SquareLoss>>(nn, "SquareLoss")

  59.     .def(py::init<std::shared_ptr<nn::Node>, std::shared_ptr<nn::Node>>(), "Create a square loss function node");

  60.     py::class_<nn::SoftmaxLoss, nn::Loss, std::shared_ptr<nn::SoftmaxLoss>>(nn, "SoftmaxLoss")

  61.     .def(py::init<std::shared_ptr<nn::Node>, std::shared_ptr<nn::Node>>(), "Create a softmax loss function node");

  62.     

  63.     nn.def("log_softmax", &nn::log_softmax, "Log softmax function", py::arg("logits"));

  64. 

  65.     nn.def("gradients", &nn::gradients, "Calculate the gradients", py::arg("loss") = nullptr, py::arg("nodes") = std::vector<std::shared_ptr<nn::Node>>{});

  66.     nn.def("pyarray_to_tensor", &tensor::pyarray_to_tensor, "Convert a numpy array to a tensor", py::arg("arr"));

  67.     nn.def("argmax", &tensor::argmax, "Get a tensor's argmax", py::arg("tensor"), py::arg("axis"));

  68.     nn.def("mean", &tensor::mean, "Get a tensor element's mean value", py::arg("tensor"));

  69.     nn.def("exp", &tensor::exp, "Get exp of a tensor", py::arg("tensor"));

  70. 

  71.     // framework test

  72.     py::module framework = m.def_submodule("framework", "Framework module");

  73.     py::module basis = framework.def_submodule("basis", "Basic modules");

  74.     

  75.     // task 1

  76.     basis.def("mul", &operators::mul<int>, "Multiply two integers", py::arg("a"), py::arg("b"));

  77.     basis.def("id", &operators::id<int>, "Identity function", py::arg("a"));

  78.     basis.def("add", &operators::add<int>, "Add two integers", py::arg("a"), py::arg("b"));

  79.     basis.def("neg", &operators::neg<int>, "Negate an integer", py::arg("a"));

  80.     basis.def("lt", &operators::lt<int>, "Less than operator", py::arg("a"), py::arg("b"));

  81.     basis.def("eq", &operators::eq<int>, "Equal operator", py::arg("a"), py::arg("b"));

  82.     basis.def("max", &operators::max<int>, "Max operator", py::arg("a"), py::arg("b"));

  83.     

  84.     // task 2

  85.     basis.def("is_close", &operators::is_close, "Check if two floats are close", py::arg("x"), py::arg("y"));

  86.     basis.def("sigmoid", &operators::sigmoid, "Sigmoid function", py::arg("x"));

  87.     basis.def("relu", &operators::relu, "ReLU function", py::arg("x"));

  88.     basis.def("inv", &operators::inv, "Inverse function", py::arg("x"));

  89.     basis.def("inv_back", &operators::inv_back, "Inv back function", py::arg("x"), py::arg("d"));

  90.     basis.def("relu_back", &operators::relu_back, "ReLU back function", py::arg("x"), py::arg("d"));

  91. 

  92.     // task 3

  93.     basis.def("negList", &operators::negList, "Negate a list of integers", py::arg("lst"));

  94. 

  95.     // task 4, 5

  96.     basis.def("addLists", &operators::addLists, "Add two lists of integers", py::arg("lst1"), py::arg("lst2"));

  97. 

  98.     // task 6

  99.     basis.def("sumList", &operators::sumList, "Sum a list of integers", py::arg("lst"));

  100. 

  101.     // task 7

  102.     basis.def("prodList", &operators::prodList, "Multiply a list of integers", py::arg("lst"));

  103. 

  104.     py::module autodiff = framework.def_submodule("autodiff", "Autodiff modules");

  105.     autodiff.def("test_central_difference", &autodiff::test_central_difference, "Test central difference");

  106.     

  107.     autodiff.def("test_addscalar", &autodiff::test_addscalar, "Test add scalar");

  108. 

  109.     autodiff.def("test_mulscalar", &autodiff::test_mulscalar, "Test mul scalar");

  110. 

  111.     autodiff.def("test_logscalar", &autodiff::test_logscalar, "Test log scalar");

  112. 

  113.     autodiff.def("test_invscalar", &autodiff::test_invscalar, "Test inv scalar");

  114. 

  115.     autodiff.def("test_sigmoidscalar", &autodiff::test_sigmoidscalar, "Test sigmoid scalar");

  116. }