nll libtorch

CMakeLists.txt

@@ -269,9 +269,9 @@ add_custom_command(
 
 # add_subdirectory(bridge)
 
-add_subdirectory(examples)
+# add_subdirectory(examples)
 add_subdirectory("test")
-add_subdirectory(demos)
+# add_subdirectory(demos)
 
 
 

bridge/include/bridge.h

@@ -72,6 +72,14 @@ bridge_tensor_t conv2d(
     int padding
 );
 
+bridge_tensor_t nll_loss(
+    bridge_tensor_t input, 
+    bridge_tensor_t target, 
+    bridge_tensor_t weight,
+    int ignoreIndex,
+    int reduction
+);
+
 bridge_tensor_t matmul(bridge_tensor_t a, bridge_tensor_t b);
 
 bridge_tensor_t max_pool2d(
@@ -104,8 +112,8 @@ proto_bridge_simple(softsign);
 
 proto_bridge_simple(tanhshrink);
 
-void split_loop(int64_t idx, int64_t n);
-void split_loop_filler(int64_t n,int64_t* ret);
+// void split_loop(int64_t idx, int64_t n);
+// void split_loop_filler(int64_t n,int64_t* ret);
 
 void show_webcam(void);
 

bridge/lib/bridge.cpp

@@ -16,7 +16,7 @@
 #include <chrono>
 #include <thread>
 
-#include <opencv2/opencv.hpp>
+// #include <opencv2/opencv.hpp>
 
 
 #define def_bridge_simple(Name) \
@@ -279,6 +279,43 @@ extern "C" bridge_tensor_t add_two_arrays(bridge_tensor_t a, bridge_tensor_t b)
     return torch_to_bridge(output);
 }
 
+extern "C" bridge_tensor_t nll_loss(
+    bridge_tensor_t input, 
+    bridge_tensor_t target, 
+    bridge_tensor_t weight,
+    int ignoreIndex,
+    int reduction
+) {
+    // Convert bridge_tensor_t to torch::Tensor
+    at::Tensor t_input = bridge_to_torch(input).to(torch::kFloat32);
+    at::Tensor t_target = bridge_to_torch(target).to(torch::kLong);
+    at::Tensor t_weight = bridge_to_torch(weight).to(torch::kFloat32);
+
+    // Map reduction int to torch::Reduction enum
+    torch::nn::functional::NLLLossFuncOptions::reduction_t reduction_enum;
+    switch (reduction) {
+        case 0: reduction_enum = torch::kNone; break;
+        case 1: reduction_enum = torch::kMean; break;
+        case 2: reduction_enum = torch::kSum; break;
+        default: reduction_enum = torch::kMean; break;
+    }
+
+    at::Tensor output = torch::nn::functional::nll_loss(
+        t_input,
+        t_target,
+        torch::nn::functional::NLLLossFuncOptions()
+            .weight(t_weight)
+            .ignore_index(ignoreIndex)
+            .reduction(reduction_enum)
+    );
+
+    if (output.dim() == 0) {
+        output = output.unsqueeze(0); // Makes scalar result 1D with 1 element
+    }
+
+    return torch_to_bridge(output);
+}
+
 // extern "C" bridge_tensor_t capture_webcam_bridge(int cam_index) {
 //     torch::Tensor image = capture_webcam(cam_index);
 //     return torch_to_bridge(image);
@@ -388,53 +425,53 @@ extern "C" float sumArray(float* arr, int* sizes, int dim) {
 }
 
 
-extern "C" void split_loop(int64_t idx, int64_t n) {
-    for (int i = 0; i < n; ++i) {
-        std::cout << "idx(" << idx << "," << n << ") = " << i << std::endl;
-        std::cout.flush();
-    }
-}
+// extern "C" void split_loop(int64_t idx, int64_t n) {
+//     for (int i = 0; i < n; ++i) {
+//         std::cout << "idx(" << idx << "," << n << ") = " << i << std::endl;
+//         std::cout.flush();
+//     }
+// }
 
-extern "C" void split_loop_filler(int64_t n,int64_t* ret) {
-    for (int i = 0; i < n; ++i) {
-        *ret = i;
-        std::this_thread::sleep_for(std::chrono::seconds(0));
-    }
-}
+// extern "C" void split_loop_filler(int64_t n,int64_t* ret) {
+//     for (int i = 0; i < n; ++i) {
+//         *ret = i;
+//         std::this_thread::sleep_for(std::chrono::seconds(0));
+//     }
+// }
 
 
 
-cv::VideoCapture open_camera(int cam_index) {
-    cv::VideoCapture cap(cam_index, cv::CAP_AVFOUNDATION);
-    if (!cap.isOpened()) {
-        std::cerr << "Could not open camera index " << cam_index << std::endl;
-        return cv::VideoCapture();
-    }
-    cap.set(cv::CAP_PROP_BUFFERSIZE, 1); // minimal internal buffering
-    cap.set(cv::CAP_PROP_FPS, 60);       // request higher FPS if possible
-    return cap;
-}
+// cv::VideoCapture open_camera(int cam_index) {
+//     cv::VideoCapture cap(cam_index, cv::CAP_AVFOUNDATION);
+//     if (!cap.isOpened()) {
+//         std::cerr << "Could not open camera index " << cam_index << std::endl;
+//         return cv::VideoCapture();
+//     }
+//     cap.set(cv::CAP_PROP_BUFFERSIZE, 1); // minimal internal buffering
+//     cap.set(cv::CAP_PROP_FPS, 60);       // request higher FPS if possible
+//     return cap;
+// }
 
 
 extern "C" void show_webcam(void) {
-    cv::VideoCapture cap;
-    cap = open_camera(0);
+    // cv::VideoCapture cap;
+    // cap = open_camera(0);
 
-    cv::Mat frame_bgr;
+    // cv::Mat frame_bgr;
 
-    while (true) {
-        if (!cap.read(frame_bgr) || frame_bgr.empty()) {
-            std::cerr << "[WARN] Empty frame, exiting" << std::endl;
-            break;
-        }
+    // while (true) {
+    //     if (!cap.read(frame_bgr) || frame_bgr.empty()) {
+    //         std::cerr << "[WARN] Empty frame, exiting" << std::endl;
+    //         break;
+    //     }
 
-        cv::imshow("webcam", frame_bgr);
+    //     cv::imshow("webcam", frame_bgr);
 
-        if (cv::waitKey(1) == 27) { // ESC key
-            break;
-        }
-    }
+    //     if (cv::waitKey(1) == 27) { // ESC key
+    //         break;
+    //     }
+    // }
 
-    cap.release();
-    cv::destroyAllWindows();
+    // cap.release();
+    // cv::destroyAllWindows();
 }

examples/split_loop/CMakeLists.txt

@@ -1,55 +1,55 @@
-find_package(OpenCV 4 REQUIRED)
+# find_package(OpenCV 4 REQUIRED)
 
-find_library(ACCELERATE Accelerate REQUIRED)
-find_library(METAL Metal REQUIRED)
-find_library(FOUNDATION Foundation REQUIRED)
+# find_library(ACCELERATE Accelerate REQUIRED)
+# find_library(METAL Metal REQUIRED)
+# find_library(FOUNDATION Foundation REQUIRED)
 
 
 
-add_library(bridge_cv OBJECT ${BRIDGE_DIR}/include/bridge.h ${BRIDGE_DIR}/lib/bridge.cpp)
+# add_library(bridge_cv OBJECT ${BRIDGE_DIR}/include/bridge.h ${BRIDGE_DIR}/lib/bridge.cpp)
 
-target_link_directories(bridge_cv PRIVATE ${LIBTORCH_DIR}/lib)
+# target_link_directories(bridge_cv PRIVATE ${LIBTORCH_DIR}/lib)
 
-target_link_libraries(
-    bridge_cv
-    PRIVATE
-    -ltorch
-    -ltorch_cpu
-    -lc10
-    -ltorch_global_deps
-    ${OpenCV_LIBS}
-    # ${TORCH_LIBRARIES}
-    ${ACCELERATE}
-    ${METAL}
-    ${FOUNDATION}
-)
+# target_link_libraries(
+#     bridge_cv
+#     PRIVATE
+#     -ltorch
+#     -ltorch_cpu
+#     -lc10
+#     -ltorch_global_deps
+#     ${OpenCV_LIBS}
+#     # ${TORCH_LIBRARIES}
+#     ${ACCELERATE}
+#     ${METAL}
+#     ${FOUNDATION}
+# )
 
-target_include_directories(
-    bridge_cv
-    PRIVATE
-    ${BRIDGE_DIR}/include
-    ${LIBTORCH_DIR}/include
-    ${LIBTORCH_DIR}/include/torch/csrc/api/include
-    # ${BRIDGE_DIR}/util
-)
+# target_include_directories(
+#     bridge_cv
+#     PRIVATE
+#     ${BRIDGE_DIR}/include
+#     ${LIBTORCH_DIR}/include
+#     ${LIBTORCH_DIR}/include/torch/csrc/api/include
+#     # ${BRIDGE_DIR}/util
+# )
 
-# if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-#   target_compile_options(bridge_cv PRIVATE -Ofast -flto -ffast-math)
-#   target_link_options(bridge_cv PRIVATE -flto)
-# endif()
+# # if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+# #   target_compile_options(bridge_cv PRIVATE -Ofast -flto -ffast-math)
+# #   target_link_options(bridge_cv PRIVATE -flto)
+# # endif()
 
 
-set(BRIDGE_CV_OBJECT_FILES $<TARGET_OBJECTS:bridge_cv>)
+# set(BRIDGE_CV_OBJECT_FILES $<TARGET_OBJECTS:bridge_cv>)
 
 
-set(CHAI_CV_LINKER_ARGS
-    -M ${PROJECT_ROOT_DIR}/lib
-    ${BRIDGE_DIR}/include/bridge.h
-    ${BRIDGE_CV_OBJECT_FILES}
-    -L ${LIBTORCH_DIR}/lib
-    ${LIBTORCH_LIBS_LINKER_ARGS}
-    --ldflags "-Wl,-rpath,${LIBTORCH_DIR}/lib"
-)
+# set(CHAI_CV_LINKER_ARGS
+#     -M ${PROJECT_ROOT_DIR}/lib
+#     ${BRIDGE_DIR}/include/bridge.h
+#     ${BRIDGE_CV_OBJECT_FILES}
+#     -L ${LIBTORCH_DIR}/lib
+#     ${LIBTORCH_LIBS_LINKER_ARGS}
+#     --ldflags "-Wl,-rpath,${LIBTORCH_DIR}/lib"
+# )
 
 
 
@@ -58,29 +58,29 @@ set(CHAI_CV_LINKER_ARGS
 
 
 
-add_executable(SplitLoop 
-    ${CMAKE_CURRENT_SOURCE_DIR}/split_loop.chpl
-    ${CHAI_LIB_FILES}
-)
+# add_executable(SplitLoop 
+#     ${CMAKE_CURRENT_SOURCE_DIR}/split_loop.chpl
+#     ${CHAI_LIB_FILES}
+# )
 
-add_dependencies(SplitLoop bridge_cv)
-# add_dependencies(SplitLoop ChAI)
-target_link_options(SplitLoop
-    PRIVATE
-    ${CHAI_CV_LINKER_ARGS}
-)
+# add_dependencies(SplitLoop bridge_cv)
+# # add_dependencies(SplitLoop ChAI)
+# target_link_options(SplitLoop
+#     PRIVATE
+#     ${CHAI_CV_LINKER_ARGS}
+# )
 
-cmake_print_variables(CHAI_CV_LINKER_ARGS)
-cmake_print_variables(OpenCV_LIBS)
-cmake_print_variables(ACCELERATE)
-cmake_print_variables(METAL)
-cmake_print_variables(FOUNDATION)
+# cmake_print_variables(CHAI_CV_LINKER_ARGS)
+# cmake_print_variables(OpenCV_LIBS)
+# cmake_print_variables(ACCELERATE)
+# cmake_print_variables(METAL)
+# cmake_print_variables(FOUNDATION)
 
-set_target_properties(SplitLoop PROPERTIES
-    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}
-)
+# set_target_properties(SplitLoop PROPERTIES
+#     RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}
+# )
 
-# if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-#   target_compile_options(SplitLoop PRIVATE -Ofast -flto -ffast-math)
-#   target_link_options(SplitLoop PRIVATE -flto)
-# endif()
+# # if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+# #   target_compile_options(SplitLoop PRIVATE -Ofast -flto -ffast-math)
+# #   target_link_options(SplitLoop PRIVATE -flto)
+# # endif()

lib/Autograd.chpl

@@ -1084,13 +1084,12 @@ record nllLossOp : serializable {
     var target: shared BaseTensorResource(?);
     var weight: shared BaseTensorResource(?);
     var ignoreIndex: int;
-    var red: bool;
     var reduction: string;
 
     proc children do return (input,target,weight);
 
     proc forward() do
-        return ndarray.nllLoss(input.array,target.array,weight.array,ignoreIndex,red,reduction);
+        return ndarray.nllLoss(input.array,target.array,weight.array,ignoreIndex,reduction);
 
     proc spec : GradOpSpec do return new dict(("operation", "nllLoss"));
 }

lib/Bridge.chpl

@@ -87,11 +87,18 @@ module Bridge {
         in a: bridge_tensor_t, 
         in b: bridge_tensor_t): bridge_tensor_t;
 
-    extern "split_loop" proc splitLoop(idx: int(64), n: int(64)): void;
+    extern "nll_loss" proc nllLoss(
+        in input: bridge_tensor_t, 
+        in target: bridge_tensor_t, 
+        in weight: bridge_tensor_t,
+        in ignoreIndex: int,
+        in reduction: int): bridge_tensor_t;
+
+    // extern "split_loop" proc splitLoop(idx: int(64), n: int(64)): void;
 
-    extern "split_loop_filler" proc splitLoopFiller(n: int(64),ret: c_ptr(int(64))): void;
+    // extern "split_loop_filler" proc splitLoopFiller(n: int(64),ret: c_ptr(int(64))): void;
 
-    extern "show_webcam" proc showWebcam(): void;
+    // extern "show_webcam" proc showWebcam(): void;
 
     // extern "capture_webcam_bridge" proc captureWebcam(
     //     in cam_index: int(32)): bridge_tensor_t;