react-native-executorch 0.4.9 → 0.5.0-nightly-6f4dd53-20251211

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

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <unordered_map>
+
+#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;
+
+class Classification : public BaseModel {
+public:
+  Classification(const std::string &modelSource,
+                 std::shared_ptr<react::CallInvoker> callInvoker);
+  std::unordered_map<std::string_view, float> generate(std::string imageSource);
+
+private:
+  std::unordered_map<std::string_view, float> postprocess(const Tensor &tensor);
+
+  cv::Size modelImageSize{0, 0};
+};
+} // namespace models::classification
+
+REGISTER_CONSTRUCTOR(models::classification::Classification, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+} // namespace rnexecutorch

package/{ios/RnExecutorch/models/classification/Constants.mm → common/rnexecutorch/models/classification/Constants.h}

@@ -1,6 +1,10 @@
-#import "Constants.h"
+#pragma once
 
-const std::string imagenet1k_v1_labels[] = {
+#include <array>
+#include <string_view>
+
+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 "
@@ -1015,3 +1019,4 @@ const std::string imagenet1k_v1_labels[] = {
     "bolete",
     "ear, spike, capitulum",
     "toilet tissue, toilet paper, bathroom tissue"};
+} // namespace rnexecutorch::models::classification::constants

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

@@ -0,0 +1,19 @@
+#include "BaseEmbeddings.h"
+
+#include <span>
+
+namespace rnexecutorch::models::embeddings {
+
+BaseEmbeddings::BaseEmbeddings(const std::string &modelSource,
+                               std::shared_ptr<react::CallInvoker> callInvoker)
+    : BaseModel(modelSource, callInvoker) {}
+
+std::shared_ptr<OwningArrayBuffer>
+BaseEmbeddings::postprocess(const Result<std::vector<EValue>> &forwardResult) {
+  auto forwardResultTensor = forwardResult->at(0).toTensor();
+  auto buffer = std::make_shared<OwningArrayBuffer>(
+      forwardResultTensor.const_data_ptr(), forwardResultTensor.nbytes());
+  return buffer;
+}
+
+} // namespace rnexecutorch::models::embeddings

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

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <rnexecutorch/models/BaseModel.h>
+
+namespace rnexecutorch::models::embeddings {
+
+class BaseEmbeddings : public BaseModel {
+public:
+  BaseEmbeddings(const std::string &modelSource,
+                 std::shared_ptr<react::CallInvoker> callInvoker);
+
+protected:
+  std::shared_ptr<OwningArrayBuffer>
+  postprocess(const Result<std::vector<EValue>> &forwardResult);
+};
+
+}; // namespace rnexecutorch::models::embeddings

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

@@ -0,0 +1,45 @@
+#include "ImageEmbeddings.h"
+
+#include <executorch/extension/tensor/tensor.h>
+#include <rnexecutorch/data_processing/ImageProcessing.h>
+#include <rnexecutorch/data_processing/Numerical.h>
+
+namespace rnexecutorch::models::embeddings {
+
+ImageEmbeddings::ImageEmbeddings(
+    const std::string &modelSource,
+    std::shared_ptr<react::CallInvoker> callInvoker)
+    : BaseEmbeddings(modelSource, callInvoker) {
+  auto inputTensors = getAllInputShapes();
+  if (inputTensors.size() == 0) {
+    throw std::runtime_error("Model seems to not take any input tensors.");
+  }
+  std::vector<int32_t> modelInputShape = inputTensors[0];
+  if (modelInputShape.size() < 2) {
+    char errorMessage[100];
+    std::snprintf(errorMessage, sizeof(errorMessage),
+                  "Unexpected model input size, expected at least 2 dimentions "
+                  "but got: %zu.",
+                  modelInputShape.size());
+    throw std::runtime_error(errorMessage);
+  }
+  modelImageSize = cv::Size(modelInputShape[modelInputShape.size() - 1],
+                            modelInputShape[modelInputShape.size() - 2]);
+}
+
+std::shared_ptr<OwningArrayBuffer>
+ImageEmbeddings::generate(std::string imageSource) {
+  auto [inputTensor, originalSize] =
+      image_processing::readImageToTensor(imageSource, getAllInputShapes()[0]);
+
+  auto forwardResult = BaseModel::forward(inputTensor);
+  if (!forwardResult.ok()) {
+    throw std::runtime_error(
+        "Function forward in ImageEmbeddings failed with error code: " +
+        std::to_string(static_cast<uint32_t>(forwardResult.error())));
+  }
+
+  return BaseEmbeddings::postprocess(forwardResult);
+}
+
+} // namespace rnexecutorch::models::embeddings

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

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <executorch/extension/tensor/tensor_ptr.h>
+#include <executorch/runtime/core/evalue.h>
+#include <opencv2/opencv.hpp>
+
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
+#include <rnexecutorch/models/embeddings/BaseEmbeddings.h>
+
+namespace rnexecutorch {
+namespace models::embeddings {
+using executorch::extension::TensorPtr;
+using executorch::runtime::EValue;
+
+class ImageEmbeddings final : public BaseEmbeddings {
+public:
+  ImageEmbeddings(const std::string &modelSource,
+                  std::shared_ptr<react::CallInvoker> callInvoker);
+  std::shared_ptr<OwningArrayBuffer> generate(std::string imageSource);
+
+private:
+  cv::Size modelImageSize{0, 0};
+};
+} // namespace models::embeddings
+
+REGISTER_CONSTRUCTOR(models::embeddings::ImageEmbeddings, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+} // namespace rnexecutorch

package/common/rnexecutorch/models/embeddings/text/TextEmbeddings.cpp

@@ -0,0 +1,60 @@
+#include "TextEmbeddings.h"
+#include <executorch/extension/tensor/tensor_ptr_maker.h>
+#include <rnexecutorch/data_processing/Numerical.h>
+
+namespace rnexecutorch::models::embeddings {
+
+using namespace executorch::extension;
+
+TextEmbeddings::TextEmbeddings(const std::string &modelSource,
+                               const std::string &tokenizerSource,
+                               std::shared_ptr<react::CallInvoker> callInvoker)
+    : BaseEmbeddings(modelSource, callInvoker),
+      tokenizer(
+          std::make_unique<TokenizerModule>(tokenizerSource, callInvoker)) {}
+
+TokenIdsWithAttentionMask TextEmbeddings::preprocess(const std::string &input) {
+  auto inputIds = tokenizer->encode(input);
+  // Tokenizers-cpp return tokens as int32, but text embedding models require
+  // int64 as input
+  std::vector<int64_t> inputIds64;
+  inputIds64.reserve(inputIds.size());
+  for (const auto &tok : inputIds) {
+    inputIds64.push_back(static_cast<int64_t>(tok));
+  }
+
+  std::vector<int64_t> attentionMask;
+  attentionMask.reserve(inputIds.size());
+  for (const auto &tok : inputIds64) {
+    // Distinguishing between real tokens and padding, 0 is for paddings, while
+    // any other tokens are relevant
+    attentionMask.push_back(tok != 0);
+  }
+  return {.inputIds = inputIds64, .attentionMask = attentionMask};
+}
+
+std::shared_ptr<OwningArrayBuffer>
+TextEmbeddings::generate(const std::string input) {
+  auto preprocessed = preprocess(input);
+
+  std::vector<int32_t> tokenIdsShape = {
+      1, static_cast<int32_t>(preprocessed.inputIds.size())};
+  std::vector<int32_t> attnMaskShape = {
+      1, static_cast<int32_t>(preprocessed.attentionMask.size())};
+
+  auto tokenIds = make_tensor_ptr(tokenIdsShape, preprocessed.inputIds.data(),
+                                  ScalarType::Long);
+  auto attnMask = make_tensor_ptr(
+      attnMaskShape, preprocessed.attentionMask.data(), ScalarType::Long);
+
+  auto forwardResult = BaseModel::forward({tokenIds, attnMask});
+  if (!forwardResult.ok()) {
+    throw std::runtime_error(
+        "Function forward in TextEmbeddings failed with error code: " +
+        std::to_string(static_cast<uint32_t>(forwardResult.error())));
+  }
+
+  return BaseEmbeddings::postprocess(forwardResult);
+}
+
+} // namespace rnexecutorch::models::embeddings

package/common/rnexecutorch/models/embeddings/text/TextEmbeddings.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
+#include <rnexecutorch/TokenizerModule.h>
+#include <rnexecutorch/models/embeddings/BaseEmbeddings.h>
+
+namespace rnexecutorch {
+namespace models::embeddings {
+
+struct TokenIdsWithAttentionMask {
+  std::vector<int64_t> inputIds;
+  std::vector<int64_t> attentionMask;
+};
+
+class TextEmbeddings final : public BaseEmbeddings {
+public:
+  TextEmbeddings(const std::string &modelSource,
+                 const std::string &tokenizerSource,
+                 std::shared_ptr<react::CallInvoker> callInvoker);
+  std::shared_ptr<OwningArrayBuffer> generate(const std::string input);
+
+private:
+  std::vector<std::vector<int32_t>> inputShapes;
+  TokenIdsWithAttentionMask preprocess(const std::string &input);
+  std::unique_ptr<TokenizerModule> tokenizer;
+};
+} // namespace models::embeddings
+
+REGISTER_CONSTRUCTOR(models::embeddings::TextEmbeddings, std::string,
+                     std::string, std::shared_ptr<react::CallInvoker>);
+} // namespace rnexecutorch

package/{ios/RnExecutorch/models/image_segmentation/Constants.mm → common/rnexecutorch/models/image_segmentation/Constants.h}

@@ -1,8 +1,13 @@
-#import "Constants.h"
+#pragma once
 
-const std::vector<std::string> deeplabv3_resnet50_labels = {
+#include <array>
+#include <string_view>
+
+namespace rnexecutorch::models::image_segmentation::constants {
+inline constexpr std::array<std::string_view, 21> kDeeplabV3Resnet50Labels = {
     "BACKGROUND", "AEROPLANE",   "BICYCLE", "BIRD",  "BOAT",
     "BOTTLE",     "BUS",         "CAR",     "CAT",   "CHAIR",
     "COW",        "DININGTABLE", "DOG",     "HORSE", "MOTORBIKE",
     "PERSON",     "POTTEDPLANT", "SHEEP",   "SOFA",  "TRAIN",
     "TVMONITOR"};
+} // namespace rnexecutorch::models::image_segmentation::constants

package/common/rnexecutorch/models/image_segmentation/ImageSegmentation.cpp

@@ -0,0 +1,168 @@
+#include "ImageSegmentation.h"
+
+#include <future>
+
+#include <executorch/extension/tensor/tensor.h>
+
+#include <rnexecutorch/data_processing/ImageProcessing.h>
+#include <rnexecutorch/data_processing/Numerical.h>
+#include <rnexecutorch/host_objects/JsiConversions.h>
+#include <rnexecutorch/models/image_segmentation/Constants.h>
+
+namespace rnexecutorch::models::image_segmentation {
+
+ImageSegmentation::ImageSegmentation(
+    const std::string &modelSource,
+    std::shared_ptr<react::CallInvoker> callInvoker)
+    : BaseModel(modelSource, callInvoker) {
+  auto inputShapes = getAllInputShapes();
+  if (inputShapes.size() == 0) {
+    throw std::runtime_error("Model seems to not take any input tensors.");
+  }
+  std::vector<int32_t> modelInputShape = inputShapes[0];
+  if (modelInputShape.size() < 2) {
+    char errorMessage[100];
+    std::snprintf(errorMessage, sizeof(errorMessage),
+                  "Unexpected model input size, expected at least 2 dimentions "
+                  "but got: %zu.",
+                  modelInputShape.size());
+    throw std::runtime_error(errorMessage);
+  }
+  modelImageSize = cv::Size(modelInputShape[modelInputShape.size() - 1],
+                            modelInputShape[modelInputShape.size() - 2]);
+  numModelPixels = modelImageSize.area();
+}
+
+std::shared_ptr<jsi::Object> ImageSegmentation::generate(
+    std::string imageSource,
+    std::set<std::string, std::less<>> classesOfInterest, bool resize) {
+  auto [inputTensor, originalSize] =
+      image_processing::readImageToTensor(imageSource, getAllInputShapes()[0]);
+
+  auto forwardResult = BaseModel::forward(inputTensor);
+  if (!forwardResult.ok()) {
+    throw std::runtime_error(
+        "Failed to forward, error: " +
+        std::to_string(static_cast<uint32_t>(forwardResult.error())));
+  }
+
+  return postprocess(forwardResult->at(0).toTensor(), originalSize,
+                     classesOfInterest, resize);
+}
+
+std::shared_ptr<jsi::Object> ImageSegmentation::postprocess(
+    const Tensor &tensor, cv::Size originalSize,
+    std::set<std::string, std::less<>> classesOfInterest, bool resize) {
+
+  auto dataPtr = static_cast<const float *>(tensor.const_data_ptr());
+  auto resultData = std::span(dataPtr, tensor.numel());
+
+  // We copy the ET-owned data to jsi array buffers that can be directly
+  // returned to JS
+  std::vector<std::shared_ptr<OwningArrayBuffer>> resultClasses;
+  resultClasses.reserve(numClasses);
+  for (std::size_t cl = 0; cl < numClasses; ++cl) {
+    auto classBuffer = std::make_shared<OwningArrayBuffer>(
+        &resultData[cl * numModelPixels], numModelPixels * sizeof(float));
+    resultClasses.push_back(classBuffer);
+  }
+
+  // Apply softmax per each pixel across all classes
+  for (std::size_t pixel = 0; pixel < numModelPixels; ++pixel) {
+    std::vector<float> classValues(numClasses);
+    for (std::size_t cl = 0; cl < numClasses; ++cl) {
+      classValues[cl] =
+          reinterpret_cast<float *>(resultClasses[cl]->data())[pixel];
+    }
+    numerical::softmax(classValues);
+    for (std::size_t cl = 0; cl < numClasses; ++cl) {
+      reinterpret_cast<float *>(resultClasses[cl]->data())[pixel] =
+          classValues[cl];
+    }
+  }
+
+  // Calculate the maximum class for each pixel
+  auto argmax =
+      std::make_shared<OwningArrayBuffer>(numModelPixels * sizeof(int32_t));
+  for (std::size_t pixel = 0; pixel < numModelPixels; ++pixel) {
+    float max = reinterpret_cast<float *>(resultClasses[0]->data())[pixel];
+    int maxInd = 0;
+    for (int cl = 1; cl < numClasses; ++cl) {
+      if (reinterpret_cast<float *>(resultClasses[cl]->data())[pixel] > max) {
+        maxInd = cl;
+        max = reinterpret_cast<float *>(resultClasses[cl]->data())[pixel];
+      }
+    }
+    reinterpret_cast<int32_t *>(argmax->data())[pixel] = maxInd;
+  }
+
+  auto buffersToReturn = std::make_shared<std::unordered_map<
+      std::string_view, std::shared_ptr<OwningArrayBuffer>>>();
+  for (std::size_t cl = 0; cl < numClasses; ++cl) {
+    if (classesOfInterest.contains(constants::kDeeplabV3Resnet50Labels[cl])) {
+      (*buffersToReturn)[constants::kDeeplabV3Resnet50Labels[cl]] =
+          resultClasses[cl];
+    }
+  }
+
+  // Resize selected classes and argmax
+  if (resize) {
+    cv::Mat argmaxMat(modelImageSize, CV_32SC1, argmax->data());
+    cv::resize(argmaxMat, argmaxMat, originalSize, 0, 0,
+               cv::InterpolationFlags::INTER_NEAREST);
+    argmax = std::make_shared<OwningArrayBuffer>(
+        argmaxMat.data, originalSize.area() * sizeof(int32_t));
+
+    for (auto &[label, arrayBuffer] : *buffersToReturn) {
+      cv::Mat classMat(modelImageSize, CV_32FC1, arrayBuffer->data());
+      cv::resize(classMat, classMat, originalSize);
+      arrayBuffer = std::make_shared<OwningArrayBuffer>(
+          classMat.data, originalSize.area() * sizeof(float));
+    }
+  }
+  return populateDictionary(argmax, buffersToReturn);
+}
+
+std::shared_ptr<jsi::Object> ImageSegmentation::populateDictionary(
+    std::shared_ptr<OwningArrayBuffer> argmax,
+    std::shared_ptr<std::unordered_map<std::string_view,
+                                       std::shared_ptr<OwningArrayBuffer>>>
+        classesToOutput) {
+  // Synchronize the invoked thread to return when the dict is constructed
+  auto promisePtr = std::make_shared<std::promise<void>>();
+  std::future<void> doneFuture = promisePtr->get_future();
+
+  std::shared_ptr<jsi::Object> dictPtr = nullptr;
+  callInvoker->invokeAsync(
+      [argmax, classesToOutput, &dictPtr, promisePtr](jsi::Runtime &runtime) {
+        dictPtr = std::make_shared<jsi::Object>(runtime);
+        auto argmaxArrayBuffer = jsi::ArrayBuffer(runtime, argmax);
+
+        auto int32ArrayCtor =
+            runtime.global().getPropertyAsFunction(runtime, "Int32Array");
+        auto int32Array =
+            int32ArrayCtor.callAsConstructor(runtime, argmaxArrayBuffer)
+                .getObject(runtime);
+        dictPtr->setProperty(runtime, "ARGMAX", int32Array);
+
+        for (auto &[classLabel, owningBuffer] : *classesToOutput) {
+          auto classArrayBuffer = jsi::ArrayBuffer(runtime, owningBuffer);
+
+          auto float32ArrayCtor =
+              runtime.global().getPropertyAsFunction(runtime, "Float32Array");
+          auto float32Array =
+              float32ArrayCtor.callAsConstructor(runtime, classArrayBuffer)
+                  .getObject(runtime);
+
+          dictPtr->setProperty(
+              runtime, jsi::String::createFromAscii(runtime, classLabel.data()),
+              float32Array);
+        }
+        promisePtr->set_value();
+      });
+
+  doneFuture.wait();
+  return dictPtr;
+}
+
+} // namespace rnexecutorch::models::image_segmentation

package/common/rnexecutorch/models/image_segmentation/ImageSegmentation.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <set>
+#include <utility>
+
+#include <executorch/extension/tensor/tensor_ptr.h>
+#include <jsi/jsi.h>
+#include <opencv2/opencv.hpp>
+
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
+#include <rnexecutorch/jsi/OwningArrayBuffer.h>
+#include <rnexecutorch/models/BaseModel.h>
+#include <rnexecutorch/models/image_segmentation/Constants.h>
+
+namespace rnexecutorch {
+namespace models::image_segmentation {
+using namespace facebook;
+
+using executorch::aten::Tensor;
+using executorch::extension::TensorPtr;
+
+class ImageSegmentation : public BaseModel {
+public:
+  ImageSegmentation(const std::string &modelSource,
+                    std::shared_ptr<react::CallInvoker> callInvoker);
+  std::shared_ptr<jsi::Object>
+  generate(std::string imageSource,
+           std::set<std::string, std::less<>> classesOfInterest, bool resize);
+
+private:
+  std::shared_ptr<jsi::Object>
+  postprocess(const Tensor &tensor, cv::Size originalSize,
+              std::set<std::string, std::less<>> classesOfInterest,
+              bool resize);
+  std::shared_ptr<jsi::Object> populateDictionary(
+      std::shared_ptr<OwningArrayBuffer> argmax,
+      std::shared_ptr<std::unordered_map<std::string_view,
+                                         std::shared_ptr<OwningArrayBuffer>>>
+          classesToOutput);
+
+  static constexpr std::size_t numClasses{
+      constants::kDeeplabV3Resnet50Labels.size()};
+  cv::Size modelImageSize;
+  std::size_t numModelPixels;
+};
+} // namespace models::image_segmentation
+
+REGISTER_CONSTRUCTOR(models::image_segmentation::ImageSegmentation, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+} // namespace rnexecutorch

package/common/rnexecutorch/models/llm/LLM.cpp

@@ -0,0 +1,98 @@
+#include "LLM.h"
+
+#include <executorch/extension/tensor/tensor.h>
+#include <filesystem>
+#include <rnexecutorch/threads/GlobalThreadPool.h>
+
+namespace rnexecutorch::models::llm {
+namespace llm = ::executorch::extension::llm;
+namespace fs = std::filesystem;
+using namespace facebook;
+using executorch::extension::TensorPtr;
+using executorch::extension::module::Module;
+using executorch::runtime::Error;
+
+LLM::LLM(const std::string &modelSource, const std::string &tokenizerSource,
+         std::shared_ptr<react::CallInvoker> callInvoker)
+    : BaseModel(modelSource, callInvoker, Module::LoadMode::File),
+      runner(
+          std::make_unique<example::Runner>(module_.get(), tokenizerSource)) {
+  auto loadResult = runner->load();
+  if (loadResult != Error::Ok) {
+    throw std::runtime_error("Failed to load LLM runner, error code: " +
+                             std::to_string(static_cast<int>(loadResult)));
+  }
+
+  memorySizeLowerBound = fs::file_size(fs::path(modelSource)) +
+                         fs::file_size(fs::path(tokenizerSource));
+}
+
+// TODO: add a way to manipulate the generation config with params
+void LLM::generate(std::string input, std::shared_ptr<jsi::Function> callback) {
+  if (!runner || !runner->is_loaded()) {
+    throw std::runtime_error("Runner is not loaded");
+  }
+
+  // Create a native callback that will invoke the JS callback on the JS thread
+  auto nativeCallback = [this, callback](const std::string &token) {
+    callInvoker->invokeAsync([callback, token](jsi::Runtime &runtime) {
+      callback->call(runtime, jsi::String::createFromUtf8(runtime, token));
+    });
+  };
+
+  auto config = llm::GenerationConfig{.echo = false, .warming = false};
+  auto error = runner->generate(input, config, nativeCallback, {});
+  if (error != executorch::runtime::Error::Ok) {
+    throw std::runtime_error("Failed to generate text, error code: " +
+                             std::to_string(static_cast<int>(error)));
+  }
+}
+
+void LLM::interrupt() {
+  if (!runner || !runner->is_loaded()) {
+    throw std::runtime_error("Can't interrupt a model that's not loaded!");
+  }
+  runner->stop();
+}
+
+size_t LLM::getGeneratedTokenCount() const noexcept {
+  if (!runner || !runner->is_loaded()) {
+    return 0;
+  }
+  return runner->stats_.num_generated_tokens;
+}
+
+size_t LLM::getMemoryLowerBound() const noexcept {
+  return memorySizeLowerBound;
+}
+
+void LLM::setCountInterval(size_t countInterval) {
+  if (!runner || !runner->is_loaded()) {
+    throw std::runtime_error("Can't configure a model that's not loaded!");
+  }
+  runner->set_count_interval(countInterval);
+}
+
+void LLM::setTimeInterval(size_t timeInterval) {
+  if (!runner || !runner->is_loaded()) {
+    throw std::runtime_error("Can't configure a model that's not loaded!");
+  }
+  runner->set_time_interval(timeInterval);
+}
+
+void LLM::setTemperature(float temperature) {
+  if (!runner || !runner->is_loaded()) {
+    throw std::runtime_error("Can't configure a model that's not loaded!");
+  }
+  runner->set_temperature(temperature);
+};
+
+void LLM::setTopp(float topp) {
+  if (!runner || !runner->is_loaded()) {
+    throw std::runtime_error("Can't configure a model that's not loaded!");
+  }
+  runner->set_topp(topp);
+}
+void LLM::unload() noexcept { runner.reset(nullptr); }
+
+} // namespace rnexecutorch::models::llm

package/common/rnexecutorch/models/llm/LLM.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <rnexecutorch/models/BaseModel.h>
+#include <runner/runner.h>
+
+namespace rnexecutorch {
+namespace models::llm {
+using namespace facebook;
+
+class LLM : public BaseModel {
+public:
+  explicit LLM(const std::string &modelSource,
+               const std::string &tokenizerSource,
+               std::shared_ptr<react::CallInvoker> callInvoker);
+
+  void generate(std::string input, std::shared_ptr<jsi::Function> callback);
+  void interrupt();
+  void unload() noexcept;
+  size_t getGeneratedTokenCount() const noexcept;
+  size_t getMemoryLowerBound() const noexcept;
+  void setCountInterval(size_t countInterval);
+  void setTemperature(float temperature);
+  void setTopp(float topp);
+  void setTimeInterval(size_t timeInterval);
+
+private:
+  std::unique_ptr<example::Runner> runner;
+};
+} // namespace models::llm
+
+REGISTER_CONSTRUCTOR(models::llm::LLM, std::string, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+} // namespace rnexecutorch

package/{ios/RnExecutorch/utils/Constants.mm → common/rnexecutorch/models/object_detection/Constants.h}

@@ -1,6 +1,12 @@
-#include "Constants.h"
+#pragma once
 
-const std::unordered_map<int, std::string> cocoLabelsMap = {
+#include <string>
+#include <unordered_map>
+
+namespace rnexecutorch::models::object_detection::constants {
+inline constexpr float IOU_THRESHOLD = 0.55;
+
+inline const std::unordered_map<int, std::string> kCocoLablesMap = {
     {1, "PERSON"},         {2, "BICYCLE"},       {3, "CAR"},
     {4, "MOTORCYCLE"},     {5, "AIRPLANE"},      {6, "BUS"},
     {7, "TRAIN"},          {8, "TRUCK"},         {9, "BOAT"},
@@ -32,3 +38,4 @@ const std::unordered_map<int, std::string> cocoLabelsMap = {
     {85, "CLOCK"},         {86, "VASE"},         {87, "SCISSORS"},
     {88, "TEDDY_BEAR"},    {89, "HAIR_DRIER"},   {90, "TOOTHBRUSH"},
     {91, "HAIR_BRUSH"}};
+} // namespace rnexecutorch::models::object_detection::constants