react-native-executorch 0.5.2 → 0.5.4

package/common/rnexecutorch/host_objects/JsiConversions.h

@@ -15,10 +15,10 @@
 
 #include <rnexecutorch/metaprogramming/TypeConcepts.h>
 #include <rnexecutorch/models/object_detection/Constants.h>
-#include <rnexecutorch/models/object_detection/Utils.h>
+#include <rnexecutorch/models/object_detection/Types.h>
 #include <rnexecutorch/models/ocr/Types.h>
 
-namespace rnexecutorch::jsiconversion {
+namespace rnexecutorch::jsi_conversion {
 
 using namespace facebook;
 
@@ -29,8 +29,6 @@ template <typename T> T getValue(const jsi::Value &val, jsi::Runtime &runtime);
 template <typename T>
   requires meta::IsNumeric<T>
 inline T getValue(const jsi::Value &val, jsi::Runtime &runtime) {
-  static_assert(std::is_integral<T>::value || std::is_floating_point<T>::value,
-                "Only integral and floating-point types are supported");
   return static_cast<T>(val.asNumber());
 }
 
@@ -46,18 +44,11 @@ inline std::string getValue<std::string>(const jsi::Value &val,
 }
 
 template <>
-inline std::vector<int32_t>
-getValue<std::vector<int32_t>>(const jsi::Value &val, jsi::Runtime &runtime) {
-  jsi::Array array = val.asObject(runtime).asArray(runtime);
-  size_t length = array.size(runtime);
-  std::vector<int32_t> result;
-  result.reserve(length);
-
-  for (size_t i = 0; i < length; ++i) {
-    jsi::Value element = array.getValueAtIndex(runtime, i);
-    result.push_back(getValue<int32_t>(element, runtime));
-  }
-  return result;
+inline std::shared_ptr<jsi::Function>
+getValue<std::shared_ptr<jsi::Function>>(const jsi::Value &val,
+                                         jsi::Runtime &runtime) {
+  return std::make_shared<jsi::Function>(
+      val.asObject(runtime).asFunction(runtime));
 }
 
 template <>
@@ -75,8 +66,8 @@ inline JSTensorViewIn getValue<JSTensorViewIn>(const jsi::Value &val,
   tensorView.sizes.reserve(numShapeDims);
 
   for (size_t i = 0; i < numShapeDims; ++i) {
-    int dim = getValue<int>(shapeArray.getValueAtIndex(runtime, i), runtime);
-    tensorView.sizes.push_back(static_cast<int32_t>(dim));
+    int32_t dim = getValue<int32_t>(shapeArray.getValueAtIndex(runtime, i), runtime);
+    tensorView.sizes.push_back(dim);
   }
 
   // On JS side, TensorPtr objects hold a 'data' property which should be either
@@ -115,38 +106,6 @@ inline JSTensorViewIn getValue<JSTensorViewIn>(const jsi::Value &val,
   return tensorView;
 }
 
-template <>
-inline std::vector<JSTensorViewIn>
-getValue<std::vector<JSTensorViewIn>>(const jsi::Value &val,
-                                      jsi::Runtime &runtime) {
-  jsi::Array array = val.asObject(runtime).asArray(runtime);
-  size_t length = array.size(runtime);
-  std::vector<JSTensorViewIn> result;
-  result.reserve(length);
-
-  for (size_t i = 0; i < length; ++i) {
-    jsi::Value element = array.getValueAtIndex(runtime, i);
-    result.push_back(getValue<JSTensorViewIn>(element, runtime));
-  }
-  return result;
-}
-
-template <>
-inline std::vector<std::string>
-getValue<std::vector<std::string>>(const jsi::Value &val,
-                                   jsi::Runtime &runtime) {
-  jsi::Array array = val.asObject(runtime).asArray(runtime);
-  size_t length = array.size(runtime);
-  std::vector<std::string> result;
-  result.reserve(length);
-
-  for (size_t i = 0; i < length; ++i) {
-    jsi::Value element = array.getValueAtIndex(runtime, i);
-    result.push_back(getValue<std::string>(element, runtime));
-  }
-  return result;
-}
-
 // C++ set from JS array. Set with heterogenerous look-up (adding std::less<>
 // enables querying with std::string_view).
 template <>
@@ -214,7 +173,26 @@ inline std::vector<T> getArrayAsVector(const jsi::Value &val,
   return result;
 }
 
+
 // Template specializations for std::vector<T> types
+template <>
+inline std::vector<JSTensorViewIn> getValue<std::vector<JSTensorViewIn>>(const jsi::Value &val,
+                                                       jsi::Runtime &runtime) {
+  return getArrayAsVector<JSTensorViewIn>(val, runtime);
+}
+
+template <>
+inline std::vector<std::string> getValue<std::vector<std::string>>(const jsi::Value &val,
+                                                       jsi::Runtime &runtime) {
+  return getArrayAsVector<std::string>(val, runtime);
+}
+
+template <>
+inline std::vector<int32_t> getValue<std::vector<int32_t>>(const jsi::Value &val,
+                                                       jsi::Runtime &runtime) {
+  return getArrayAsVector<int32_t>(val, runtime);
+}
+
 template <>
 inline std::vector<float> getValue<std::vector<float>>(const jsi::Value &val,
                                                        jsi::Runtime &runtime) {
@@ -299,17 +277,17 @@ inline jsi::Value getJsiValue(const std::vector<int32_t> &vec,
   for (size_t i = 0; i < vec.size(); i++) {
     array.setValueAtIndex(runtime, i, jsi::Value(static_cast<int>(vec[i])));
   }
-  return jsi::Value(runtime, array);
+  return {runtime, array};
 }
 
 inline jsi::Value getJsiValue(int val, jsi::Runtime &runtime) {
-  return jsi::Value(runtime, val);
+  return {runtime, val};
 }
 
 inline jsi::Value getJsiValue(const std::shared_ptr<OwningArrayBuffer> &buf,
                               jsi::Runtime &runtime) {
   jsi::ArrayBuffer arrayBuffer(runtime, buf);
-  return jsi::Value(runtime, arrayBuffer);
+  return {runtime, arrayBuffer};
 }
 
 inline jsi::Value
@@ -320,7 +298,7 @@ getJsiValue(const std::vector<std::shared_ptr<OwningArrayBuffer>> &vec,
     jsi::ArrayBuffer arrayBuffer(runtime, vec[i]);
     array.setValueAtIndex(runtime, i, jsi::Value(runtime, arrayBuffer));
   }
-  return jsi::Value(runtime, array);
+  return {runtime, array};
 }
 
 inline jsi::Value getJsiValue(const std::vector<JSTensorViewOut> &vec,
@@ -339,7 +317,7 @@ inline jsi::Value getJsiValue(const std::vector<JSTensorViewOut> &vec,
 
     array.setValueAtIndex(runtime, i, tensorObj);
   }
-  return jsi::Value(runtime, array);
+  return {runtime, array};
 }
 
 inline jsi::Value getJsiValue(const std::string &str, jsi::Runtime &runtime) {
@@ -357,8 +335,9 @@ getJsiValue(const std::unordered_map<std::string_view, float> &map,
   return mapObj;
 }
 
-inline jsi::Value getJsiValue(const std::vector<Detection> &detections,
-                              jsi::Runtime &runtime) {
+inline jsi::Value getJsiValue(
+    const std::vector<models::object_detection::types::Detection> &detections,
+    jsi::Runtime &runtime) {
   jsi::Array array(runtime, detections.size());
   for (std::size_t i = 0; i < detections.size(); ++i) {
     jsi::Object detection(runtime);
@@ -371,16 +350,18 @@ inline jsi::Value getJsiValue(const std::vector<Detection> &detections,
     detection.setProperty(runtime, "bbox", bbox);
     detection.setProperty(
         runtime, "label",
-        jsi::String::createFromAscii(runtime,
-                                     COCO_LABELS_MAP.at(detections[i].label)));
+        jsi::String::createFromAscii(
+            runtime, models::object_detection::constants::kCocoLablesMap.at(
+                         detections[i].label)));
     detection.setProperty(runtime, "score", detections[i].score);
     array.setValueAtIndex(runtime, i, detection);
   }
   return array;
 }
 
-inline jsi::Value getJsiValue(const std::vector<OCRDetection> &detections,
-                              jsi::Runtime &runtime) {
+inline jsi::Value
+getJsiValue(const std::vector<models::ocr::types::OCRDetection> &detections,
+            jsi::Runtime &runtime) {
   auto jsiDetections = jsi::Array(runtime, detections.size());
   for (size_t i = 0; i < detections.size(); ++i) {
     const auto &detection = detections[i];
@@ -407,4 +388,4 @@ inline jsi::Value getJsiValue(const std::vector<OCRDetection> &detections,
   return jsiDetections;
 }
 
-} // namespace rnexecutorch::jsiconversion
+} // namespace rnexecutorch::jsi_conversion

package/common/rnexecutorch/host_objects/ModelHostObject.h

@@ -1,6 +1,12 @@
 #pragma once
 
 #include <ReactCommon/CallInvoker.h>
+#include <sstream>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <type_traits>
+
 #include <memory.h>
 #include <rnexecutorch/TokenizerModule.h>
 #include <rnexecutorch/host_objects/JSTensorViewOut.h>
@@ -10,12 +16,9 @@
 #include <rnexecutorch/metaprogramming/FunctionHelpers.h>
 #include <rnexecutorch/metaprogramming/TypeConcepts.h>
 #include <rnexecutorch/models/BaseModel.h>
+#include <rnexecutorch/models/llm/LLM.h>
 #include <rnexecutorch/models/ocr/OCR.h>
 #include <rnexecutorch/models/vertical_ocr/VerticalOCR.h>
-#include <string>
-#include <thread>
-#include <tuple>
-#include <type_traits>
 
 namespace rnexecutorch {
 
@@ -24,18 +27,18 @@ public:
   explicit ModelHostObject(const std::shared_ptr<Model> &model,
                            std::shared_ptr<react::CallInvoker> callInvoker)
       : model(model), callInvoker(callInvoker) {
-    if constexpr (meta::DerivedFromOrSameAs<Model, BaseModel>) {
+    if constexpr (meta::DerivedFromOrSameAs<Model, models::BaseModel>) {
       addFunctions(
           JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
     }
 
-    if constexpr (meta::DerivedFromOrSameAs<Model, BaseModel>) {
+    if constexpr (meta::DerivedFromOrSameAs<Model, models::BaseModel>) {
       addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
                                        promiseHostFunction<&Model::forwardJS>,
                                        "forward"));
     }
 
-    if constexpr (meta::DerivedFromOrSameAs<Model, BaseModel>) {
+    if constexpr (meta::DerivedFromOrSameAs<Model, models::BaseModel>) {
       addFunctions(JSI_EXPORT_FUNCTION(
           ModelHostObject<Model>, promiseHostFunction<&Model::getInputShape>,
           "getInputShape"));
@@ -59,6 +62,30 @@ public:
                                        "decode"));
     }
 
+    if constexpr (meta::HasTranscribe<Model>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::transcribe>,
+                                       "transcribe"));
+    }
+
+    if constexpr (meta::HasStream<Model>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::stream>,
+                                       "stream"));
+    }
+
+    if constexpr (meta::HasStreamInsert<Model>) {
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>, promiseHostFunction<&Model::streamInsert>,
+          "streamInsert"));
+    }
+
+    if constexpr (meta::HasStreamStop<Model>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::streamStop>,
+                                       "streamStop"));
+    }
+
     if constexpr (meta::SameAs<Model, TokenizerModule>) {
       addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
                                        promiseHostFunction<&Model::encode>,
@@ -77,12 +104,26 @@ public:
                                        promiseHostFunction<&Model::tokenToId>,
                                        "tokenToId"));
     }
-    if constexpr (meta::SameAs<Model, OCR>) {
+
+    if constexpr (meta::SameAs<Model, models::llm::LLM>) {
+      addFunctions(JSI_EXPORT_FUNCTION(ModelHostObject<Model>,
+                                       promiseHostFunction<&Model::generate>,
+                                       "generate"));
+
+      addFunctions(JSI_EXPORT_FUNCTION(
+          ModelHostObject<Model>, synchronousHostFunction<&Model::interrupt>,
+          "interrupt"));
+
+      addFunctions(
+          JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
+    }
+
+    if constexpr (meta::SameAs<Model, models::ocr::OCR>) {
       addFunctions(
           JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
     }
 
-    if constexpr (meta::SameAs<Model, VerticalOCR>) {
+    if constexpr (meta::SameAs<Model, models::ocr::VerticalOCR>) {
       addFunctions(
           JSI_EXPORT_FUNCTION(ModelHostObject<Model>, unload, "unload"));
     }
@@ -93,10 +134,10 @@ public:
   template <auto FnPtr> JSI_HOST_FUNCTION(synchronousHostFunction) {
     constexpr std::size_t functionArgCount = meta::getArgumentCount(FnPtr);
     if (functionArgCount != count) {
-      char errorMessage[100];
-      std::snprintf(errorMessage, sizeof(errorMessage),
-                    "Argument count mismatch, was expecting: %zu but got: %zu",
-                    functionArgCount, count);
+      std::stringstream ss;
+      ss << "Argument count mismatch, was expecting: " << functionArgCount
+         << " but got: " << count;
+      const auto errorMessage = ss.str();
       throw jsi::JSError(runtime, errorMessage);
     }
 
@@ -112,7 +153,7 @@ public:
         // For non-void functions, capture the result and convert it
         auto result =
             std::apply(std::bind_front(FnPtr, model), std::move(argsConverted));
-        return jsiconversion::getJsiValue(std::move(result), runtime);
+        return jsi_conversion::getJsiValue(std::move(result), runtime);
       }
     } catch (const std::runtime_error &e) {
       // This catch should be merged with the next one
@@ -129,6 +170,9 @@ public:
     }
   }
 
+  // A generic host function that resolves a promise with a result of a
+  // function. JSI arguments are converted to the types provided in the function
+  // signature, and the return value is converted back to JSI before resolving.
   template <auto FnPtr> JSI_HOST_FUNCTION(promiseHostFunction) {
     auto promise = Promise::createPromise(
         runtime, callInvoker,
@@ -136,11 +180,10 @@ public:
           constexpr std::size_t functionArgCount =
               meta::getArgumentCount(FnPtr);
           if (functionArgCount != count) {
-            char errorMessage[100];
-            std::snprintf(
-                errorMessage, sizeof(errorMessage),
-                "Argument count mismatch, was expecting: %zu but got: %zu",
-                functionArgCount, count);
+            std::stringstream ss;
+            ss << "Argument count mismatch, was expecting: " << functionArgCount
+               << " but got: " << count;
+            const auto errorMessage = ss.str();
             promise->reject(errorMessage);
             return;
           }
@@ -171,11 +214,11 @@ public:
                                            std::move(argsConverted));
                   // The result is copied. It should either be quickly copiable,
                   // or passed with a shared_ptr.
-                  callInvoker->invokeAsync([promise,
-                                            result](jsi::Runtime &runtime) {
-                    promise->resolve(
-                        jsiconversion::getJsiValue(std::move(result), runtime));
-                  });
+                  callInvoker->invokeAsync(
+                      [promise, result](jsi::Runtime &runtime) {
+                        promise->resolve(jsi_conversion::getJsiValue(
+                            std::move(result), runtime));
+                      });
                 }
               } catch (const std::runtime_error &e) {
                 // This catch should be merged with the next two

package/common/rnexecutorch/metaprogramming/ConstructorHelpers.h

@@ -87,7 +87,7 @@ std::tuple<Types...> fillConstructorTupleFromArgs(
     if constexpr (I == lastIndex) {
       return jsCallInvoker;
     } else {
-      return jsiconversion::getValue<Types>(args[I], runtime);
+      return jsi_conversion::getValue<Types>(args[I], runtime);
     }
   }()...);
 }
@@ -118,12 +118,14 @@ auto createConstructorArgsWithCallInvoker(
 
 } // namespace meta
 
-// A helper macro to create ConstructorTraits for a class. The variadic pack
-// ("...") should list the types of the constructor arguments.
-// A class declaration is added so that we don't need to include the class
-// definition.
+/**
+ * @brief A helper macro to create ConstructorTraits for a class. The variadic
+ * pack
+ * ("...") should list the types of the constructor arguments.
+ * @note The Class must be fully declared or forward-declared before this macro
+ * is invoked
+ */
 #define REGISTER_CONSTRUCTOR(Class, ...)                                       \
-  class Class;                                                                 \
   template <> struct meta::ConstructorTraits<Class> {                          \
     using arg_types = std::tuple<__VA_ARGS__>;                                 \
   }

package/common/rnexecutorch/metaprogramming/FunctionHelpers.h

@@ -23,7 +23,7 @@ template <typename... Types, std::size_t... I>
 std::tuple<Types...> fillTupleFromArgs(std::index_sequence<I...>,
                                        const jsi::Value *args,
                                        jsi::Runtime &runtime) {
-  return std::make_tuple(jsiconversion::getValue<Types>(args[I], runtime)...);
+  return std::make_tuple(jsi_conversion::getValue<Types>(args[I], runtime)...);
 }
 
 /**

package/common/rnexecutorch/metaprogramming/TypeConcepts.h

@@ -26,6 +26,26 @@ concept HasDecode = requires(T t) {
   { &T::decode };
 };
 
+template <typename T>
+concept HasTranscribe = requires(T t) {
+  { &T::transcribe };
+};
+
+template <typename T>
+concept HasStream = requires(T t) {
+  { &T::stream };
+};
+
+template <typename T>
+concept HasStreamInsert = requires(T t) {
+  { &T::streamInsert };
+};
+
+template <typename T>
+concept HasStreamStop = requires(T t) {
+  { &T::streamStop };
+};
+
 template <typename T>
 concept IsNumeric = std::is_arithmetic_v<T>;
 
@@ -34,4 +54,4 @@ concept ProvidesMemoryLowerBound = requires(T t) {
   { &T::getMemoryLowerBound };
 };
 
-} // namespace rnexecutorch::meta
+} // namespace rnexecutorch::meta

package/common/rnexecutorch/models/BaseModel.cpp

@@ -4,7 +4,7 @@
 #include <filesystem>
 #include <stdexcept>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models {
 
 using namespace facebook;
 using namespace executorch::extension;
@@ -142,7 +142,8 @@ BaseModel::getMethodMeta(const std::string &methodName) {
   return module_->method_meta(methodName);
 }
 
-Result<std::vector<EValue>> BaseModel::forward(const EValue &input_evalue) {
+Result<std::vector<EValue>>
+BaseModel::forward(const EValue &input_evalue) const {
   if (!module_) {
     throw std::runtime_error("Model not loaded: Cannot perform forward pass");
   }
@@ -150,7 +151,7 @@ Result<std::vector<EValue>> BaseModel::forward(const EValue &input_evalue) {
 }
 
 Result<std::vector<EValue>>
-BaseModel::forward(const std::vector<EValue> &input_evalues) {
+BaseModel::forward(const std::vector<EValue> &input_evalues) const {
   if (!module_) {
     throw std::runtime_error("Model not loaded: Cannot perform forward pass");
   }
@@ -178,4 +179,4 @@ BaseModel::getTensorShape(const executorch::aten::Tensor &tensor) {
   return std::vector<int32_t>(sizes.begin(), sizes.end());
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models

package/common/rnexecutorch/models/BaseModel.h

@@ -3,6 +3,7 @@
 #include <string>
 #include <vector>
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <ReactCommon/CallInvoker.h>
 #include <executorch/extension/module/module.h>
 #include <jsi/jsi.h>
@@ -10,6 +11,7 @@
 #include <rnexecutorch/host_objects/JSTensorViewOut.h>
 
 namespace rnexecutorch {
+namespace models {
 using namespace facebook;
 using executorch::runtime::EValue;
 using executorch::runtime::Result;
@@ -24,8 +26,9 @@ public:
   getAllInputShapes(std::string methodName = "forward");
   std::vector<JSTensorViewOut>
   forwardJS(std::vector<JSTensorViewIn> tensorViewVec);
-  Result<std::vector<EValue>> forward(const EValue &input_value);
-  Result<std::vector<EValue>> forward(const std::vector<EValue> &input_value);
+  Result<std::vector<EValue>> forward(const EValue &input_value) const;
+  Result<std::vector<EValue>>
+  forward(const std::vector<EValue> &input_value) const;
   Result<std::vector<EValue>> execute(const std::string &methodName,
                                       const std::vector<EValue> &input_value);
   Result<executorch::runtime::MethodMeta>
@@ -43,5 +46,8 @@ private:
   std::size_t memorySizeLowerBound{0};
   std::vector<int32_t> getTensorShape(const executorch::aten::Tensor &tensor);
 };
+} // namespace models
 
+REGISTER_CONSTRUCTOR(models::BaseModel, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/models/classification/Classification.cpp

@@ -6,7 +6,7 @@
 #include <rnexecutorch/data_processing/Numerical.h>
 #include <rnexecutorch/models/classification/Constants.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::classification {
 
 Classification::Classification(const std::string &modelSource,
                                std::shared_ptr<react::CallInvoker> callInvoker)
@@ -31,7 +31,7 @@ Classification::Classification(const std::string &modelSource,
 std::unordered_map<std::string_view, float>
 Classification::generate(std::string imageSource) {
   auto inputTensor =
-      imageprocessing::readImageToTensor(imageSource, getAllInputShapes()[0])
+      image_processing::readImageToTensor(imageSource, getAllInputShapes()[0])
           .first;
   auto forwardResult = BaseModel::forward(inputTensor);
   if (!forwardResult.ok()) {
@@ -49,13 +49,13 @@ Classification::postprocess(const Tensor &tensor) {
       static_cast<const float *>(tensor.const_data_ptr()), tensor.numel());
   std::vector<float> resultVec(resultData.begin(), resultData.end());
 
-  if (resultVec.size() != IMAGENET1K_V1_LABELS.size()) {
+  if (resultVec.size() != constants::kImagenet1kV1Labels.size()) {
     char errorMessage[100];
     std::snprintf(
         errorMessage, sizeof(errorMessage),
         "Unexpected classification output size, was expecting: %zu classes "
         "but got: %zu classes",
-        IMAGENET1K_V1_LABELS.size(), resultVec.size());
+        constants::kImagenet1kV1Labels.size(), resultVec.size());
     throw std::runtime_error(errorMessage);
   }
 
@@ -63,10 +63,10 @@ Classification::postprocess(const Tensor &tensor) {
 
   std::unordered_map<std::string_view, float> probs;
   for (std::size_t cl = 0; cl < resultVec.size(); ++cl) {
-    probs[IMAGENET1K_V1_LABELS[cl]] = resultVec[cl];
+    probs[constants::kImagenet1kV1Labels[cl]] = resultVec[cl];
   }
 
   return probs;
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::classification

package/common/rnexecutorch/models/classification/Classification.h

@@ -5,9 +5,11 @@
 #include <executorch/extension/tensor/tensor_ptr.h>
 #include <opencv2/opencv.hpp>
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <rnexecutorch/models/BaseModel.h>
 
 namespace rnexecutorch {
+namespace models::classification {
 using executorch::aten::Tensor;
 using executorch::extension::TensorPtr;
 
@@ -22,5 +24,8 @@ private:
 
   cv::Size modelImageSize{0, 0};
 };
+} // namespace models::classification
 
+REGISTER_CONSTRUCTOR(models::classification::Classification, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/models/classification/Constants.h

@@ -3,8 +3,8 @@
 #include <array>
 #include <string_view>
 
-namespace rnexecutorch {
-inline constexpr std::array<std::string_view, 1000> IMAGENET1K_V1_LABELS = {
+namespace rnexecutorch::models::classification::constants {
+inline constexpr std::array<std::string_view, 1000> kImagenet1kV1Labels = {
     "tench, Tinca tinca",
     "goldfish, Carassius auratus",
     "great white shark, white shark, man-eater, man-eating shark, Carcharodon "
@@ -1019,4 +1019,4 @@ inline constexpr std::array<std::string_view, 1000> IMAGENET1K_V1_LABELS = {
     "bolete",
     "ear, spike, capitulum",
     "toilet tissue, toilet paper, bathroom tissue"};
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::classification::constants

package/common/rnexecutorch/models/embeddings/BaseEmbeddings.cpp

@@ -2,7 +2,7 @@
 
 #include <span>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::embeddings {
 
 BaseEmbeddings::BaseEmbeddings(const std::string &modelSource,
                                std::shared_ptr<react::CallInvoker> callInvoker)
@@ -24,4 +24,4 @@ BaseEmbeddings::postprocess(const Result<std::vector<EValue>> &forwardResult) {
   return createBuffer(modelOutput.data(), modelOutput.size_bytes());
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::embeddings

package/common/rnexecutorch/models/embeddings/BaseEmbeddings.h

@@ -2,7 +2,7 @@
 
 #include <rnexecutorch/models/BaseModel.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::embeddings {
 
 class BaseEmbeddings : public BaseModel {
 public:
@@ -14,4 +14,4 @@ protected:
   postprocess(const Result<std::vector<EValue>> &forwardResult);
 };
 
-}; // namespace rnexecutorch
+}; // namespace rnexecutorch::models::embeddings

package/common/rnexecutorch/models/embeddings/image/ImageEmbeddings.cpp

@@ -4,7 +4,7 @@
 #include <rnexecutorch/data_processing/ImageProcessing.h>
 #include <rnexecutorch/data_processing/Numerical.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::embeddings {
 
 ImageEmbeddings::ImageEmbeddings(
     const std::string &modelSource,
@@ -30,7 +30,7 @@ ImageEmbeddings::ImageEmbeddings(
 std::shared_ptr<OwningArrayBuffer>
 ImageEmbeddings::generate(std::string imageSource) {
   auto [inputTensor, originalSize] =
-      imageprocessing::readImageToTensor(imageSource, getAllInputShapes()[0]);
+      image_processing::readImageToTensor(imageSource, getAllInputShapes()[0]);
 
   auto forwardResult = BaseModel::forward(inputTensor);
   if (!forwardResult.ok()) {
@@ -42,4 +42,4 @@ ImageEmbeddings::generate(std::string imageSource) {
   return BaseEmbeddings::postprocess(forwardResult);
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::embeddings