react-native-executorch 0.4.7 → 0.5.1-rc.0

package/common/rnexecutorch/metaprogramming/TypeConcepts.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <concepts>
+#include <type_traits>
+
+namespace rnexecutorch::meta {
+
+template <typename T, typename Base>
+concept DerivedFromOrSameAs = std::is_base_of_v<Base, T>;
+
+template <typename T, typename Base>
+concept SameAs = std::is_same_v<Base, T>;
+
+template <typename T>
+concept HasGenerate = requires(T t) {
+  { &T::generate };
+};
+
+template <typename T>
+concept HasEncode = requires(T t) {
+  { &T::encode };
+};
+
+template <typename T>
+concept HasDecode = requires(T t) {
+  { &T::decode };
+};
+
+template <typename T>
+concept IsNumeric = std::is_arithmetic_v<T>;
+
+template <typename T>
+concept ProvidesMemoryLowerBound = requires(T t) {
+  { &T::getMemoryLowerBound };
+};
+
+} // namespace rnexecutorch::meta

package/common/rnexecutorch/models/BaseModel.cpp

@@ -0,0 +1,181 @@
+#include "BaseModel.h"
+
+#include <executorch/extension/tensor/tensor.h>
+#include <filesystem>
+#include <stdexcept>
+
+namespace rnexecutorch {
+
+using namespace facebook;
+using namespace executorch::extension;
+using ::executorch::runtime::Error;
+
+BaseModel::BaseModel(const std::string &modelSource,
+                     std::shared_ptr<react::CallInvoker> callInvoker)
+    : callInvoker(callInvoker),
+      module_(std::make_unique<Module>(
+          modelSource, Module::LoadMode::MmapUseMlockIgnoreErrors)) {
+  Error loadError = module_->load();
+  if (loadError != Error::Ok) {
+    throw std::runtime_error("Failed to load model: Error " +
+                             std::to_string(static_cast<int>(loadError)));
+  }
+  // We use the size of the model .pte file as the lower bound for the memory
+  // occupied by the ET module. This is not the whole size however, the module
+  // also allocates planned memory (for ET execution) and backend-specific
+  // memory (e.g. what XNNPACK operates on).
+  std::filesystem::path modelPath{modelSource};
+  memorySizeLowerBound = std::filesystem::file_size(modelPath);
+}
+
+std::vector<int32_t> BaseModel::getInputShape(std::string method_name,
+                                              int32_t index) {
+  if (!module_) {
+    throw std::runtime_error("Model not loaded: Cannot get input shape");
+  }
+
+  auto method_meta = module_->method_meta(method_name);
+  if (!method_meta.ok()) {
+    throw std::runtime_error(
+        "Failed to get metadata for method '" + method_name + "': Error " +
+        std::to_string(static_cast<int>(method_meta.error())));
+  }
+
+  auto input_meta = method_meta->input_tensor_meta(index);
+  if (!input_meta.ok()) {
+    throw std::runtime_error(
+        "Failed to get metadata for input tensor at index " +
+        std::to_string(index) + " in method '" + method_name + "': Error " +
+        std::to_string(static_cast<int>(input_meta.error())));
+  }
+
+  auto sizes = input_meta->sizes();
+  std::vector<int32_t> input_shape(sizes.begin(), sizes.end());
+  return input_shape;
+}
+
+std::vector<std::vector<int32_t>>
+BaseModel::getAllInputShapes(std::string methodName) {
+  if (!module_) {
+    throw std::runtime_error("Model not loaded: Cannot get all input shapes");
+  }
+
+  auto method_meta = module_->method_meta(methodName);
+  if (!method_meta.ok()) {
+    throw std::runtime_error(
+        "Failed to get metadata for method '" + methodName + "': Error " +
+        std::to_string(static_cast<int>(method_meta.error())));
+  }
+  std::vector<std::vector<int32_t>> output;
+  std::size_t numInputs = method_meta->num_inputs();
+  output.reserve(numInputs);
+  for (std::size_t input = 0; input < numInputs; ++input) {
+    auto input_meta = method_meta->input_tensor_meta(input);
+    if (!input_meta.ok()) {
+      throw std::runtime_error(
+          "Failed to get metadata for input tensor at index " +
+          std::to_string(input) + " in method '" + methodName + "': Error " +
+          std::to_string(static_cast<int>(input_meta.error())));
+    }
+    auto shape = input_meta->sizes();
+    output.emplace_back(std::vector<int32_t>(shape.begin(), shape.end()));
+  }
+  return output;
+}
+
+/// @brief This method is a forward wrapper that is created solely to be exposed
+/// to JS. It is not meant to be used within C++. If you want to call forward
+/// from C++ on a BaseModel, please use BaseModel::forward.
+std::vector<JSTensorViewOut>
+BaseModel::forwardJS(std::vector<JSTensorViewIn> tensorViewVec) {
+  if (!module_) {
+    throw std::runtime_error("Model not loaded: Cannot perform forward pass");
+  }
+  std::vector<executorch::runtime::EValue> evalues;
+  evalues.reserve(tensorViewVec.size());
+  // Because EValue doesn't hold to the dynamic data and metadata from
+  // TensorPtr, we need to make sure that the TensorPtr for each EValue is valid
+  // as long as that EValue is in use. Therefore we create a vec solely for
+  // keeping references to the TensorPtr
+  std::vector<TensorPtr> tensorPtrs;
+  tensorPtrs.reserve(evalues.size());
+
+  for (size_t i = 0; i < tensorViewVec.size(); i++) {
+    const auto &currTensorView = tensorViewVec[i];
+    auto tensorPtr =
+        make_tensor_ptr(currTensorView.sizes, currTensorView.dataPtr,
+                        currTensorView.scalarType);
+    tensorPtrs.emplace_back(tensorPtr);
+    evalues.emplace_back(*tensorPtr); // Dereference TensorPtr to get Tensor,
+                                      // which implicitly converts to EValue
+  }
+
+  auto result = module_->forward(evalues);
+  if (!result.ok()) {
+    throw std::runtime_error("Forward pass failed: Error " +
+                             std::to_string(static_cast<int>(result.error())));
+  }
+
+  auto &outputs = result.get();
+  std::vector<JSTensorViewOut> output;
+  output.reserve(outputs.size());
+
+  // Convert ET outputs to a vector of JSTensorViewOut which are later
+  // converted to JSI types via JsiConversions.h
+  for (size_t i = 0; i < outputs.size(); i++) {
+    auto &outputTensor = outputs[i].toTensor();
+    std::vector<int32_t> sizes = getTensorShape(outputTensor);
+    size_t bufferSize = outputTensor.numel() * outputTensor.element_size();
+    auto buffer = std::make_shared<OwningArrayBuffer>(bufferSize);
+    std::memcpy(buffer->data(), outputTensor.const_data_ptr(), bufferSize);
+    auto jsTensor = JSTensorViewOut(sizes, outputTensor.scalar_type(), buffer);
+    output.emplace_back(jsTensor);
+  }
+  return output;
+}
+
+Result<executorch::runtime::MethodMeta>
+BaseModel::getMethodMeta(const std::string &methodName) {
+  if (!module_) {
+    throw std::runtime_error("Model not loaded: Cannot get method meta!");
+  }
+  return module_->method_meta(methodName);
+}
+
+Result<std::vector<EValue>> BaseModel::forward(const EValue &input_evalue) {
+  if (!module_) {
+    throw std::runtime_error("Model not loaded: Cannot perform forward pass");
+  }
+  return module_->forward(input_evalue);
+}
+
+Result<std::vector<EValue>>
+BaseModel::forward(const std::vector<EValue> &input_evalues) {
+  if (!module_) {
+    throw std::runtime_error("Model not loaded: Cannot perform forward pass");
+  }
+  return module_->forward(input_evalues);
+}
+
+Result<std::vector<EValue>>
+BaseModel::execute(const std::string &methodName,
+                   const std::vector<EValue> &input_value) {
+  if (!module_) {
+    throw std::runtime_error("Model not loaded, cannot run execute.");
+  }
+  return module_->execute(methodName, input_value);
+}
+
+std::size_t BaseModel::getMemoryLowerBound() const noexcept {
+  return memorySizeLowerBound;
+}
+
+void BaseModel::unload() noexcept { module_.reset(nullptr); }
+
+std::vector<int32_t>
+BaseModel::getTensorShape(const executorch::aten::Tensor &tensor) {
+  auto sizes = tensor.sizes();
+  return std::vector<int32_t>(sizes.begin(), sizes.end());
+}
+
+} // namespace rnexecutorch

package/common/rnexecutorch/models/BaseModel.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <ReactCommon/CallInvoker.h>
+#include <executorch/extension/module/module.h>
+#include <jsi/jsi.h>
+#include <rnexecutorch/host_objects/JSTensorViewIn.h>
+#include <rnexecutorch/host_objects/JSTensorViewOut.h>
+
+namespace rnexecutorch {
+using namespace facebook;
+using executorch::runtime::EValue;
+using executorch::runtime::Result;
+class BaseModel {
+public:
+  BaseModel(const std::string &modelSource,
+            std::shared_ptr<react::CallInvoker> callInvoker);
+  std::size_t getMemoryLowerBound() const noexcept;
+  void unload() noexcept;
+  std::vector<int32_t> getInputShape(std::string method_name, int32_t index);
+  std::vector<std::vector<int32_t>>
+  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>> execute(const std::string &methodName,
+                                      const std::vector<EValue> &input_value);
+  Result<executorch::runtime::MethodMeta>
+  getMethodMeta(const std::string &methodName);
+
+protected:
+  // If possible, models should not use the JS runtime to keep JSI internals
+  // away from logic, however, sometimes this would incur too big of a penalty
+  // (unnecessary copies instead of working on JS memory). In this case
+  // CallInvoker can be used to get jsi::Runtime, and use it in a safe manner.
+  std::shared_ptr<react::CallInvoker> callInvoker;
+  std::unique_ptr<executorch::extension::Module> module_;
+
+private:
+  std::size_t memorySizeLowerBound{0};
+  std::vector<int32_t> getTensorShape(const executorch::aten::Tensor &tensor);
+};
+
+} // namespace rnexecutorch

package/common/rnexecutorch/models/EncoderDecoderBase.cpp

@@ -0,0 +1,21 @@
+#include <rnexecutorch/models/EncoderDecoderBase.h>
+
+namespace rnexecutorch {
+
+EncoderDecoderBase::EncoderDecoderBase(
+    const std::string &encoderPath, const std::string &decoderPath,
+    std::shared_ptr<react::CallInvoker> callInvoker)
+    : callInvoker(callInvoker),
+      encoder_(std::make_unique<BaseModel>(encoderPath, callInvoker)),
+      decoder_(std::make_unique<BaseModel>(decoderPath, callInvoker)) {};
+
+size_t EncoderDecoderBase::getMemoryLowerBound() const noexcept {
+  return encoder_->getMemoryLowerBound() + decoder_->getMemoryLowerBound();
+}
+
+void EncoderDecoderBase::unload() noexcept {
+  encoder_.reset(nullptr);
+  decoder_.reset(nullptr);
+}
+
+} // namespace rnexecutorch

package/common/rnexecutorch/models/EncoderDecoderBase.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <memory>
+#include <rnexecutorch/models/BaseModel.h>
+#include <string>
+
+namespace rnexecutorch {
+
+using namespace facebook;
+using executorch::aten::Tensor;
+using executorch::runtime::EValue;
+
+class EncoderDecoderBase {
+public:
+  explicit EncoderDecoderBase(const std::string &encoderPath,
+                              const std::string &decoderPath,
+                              std::shared_ptr<react::CallInvoker> callInvoker);
+  size_t getMemoryLowerBound() const noexcept;
+  void unload() noexcept;
+
+protected:
+  std::shared_ptr<react::CallInvoker> callInvoker;
+  std::unique_ptr<BaseModel> encoder_;
+  std::unique_ptr<BaseModel> decoder_;
+
+private:
+  size_t memorySizeLowerBound;
+};
+
+} // namespace rnexecutorch

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

@@ -0,0 +1,72 @@
+#include "Classification.h"
+
+#include <future>
+
+#include <rnexecutorch/data_processing/ImageProcessing.h>
+#include <rnexecutorch/data_processing/Numerical.h>
+#include <rnexecutorch/models/classification/Constants.h>
+
+namespace rnexecutorch {
+
+Classification::Classification(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]);
+}
+
+std::unordered_map<std::string_view, float>
+Classification::generate(std::string imageSource) {
+  auto inputTensor =
+      imageprocessing::readImageToTensor(imageSource, getAllInputShapes()[0])
+          .first;
+  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());
+}
+
+std::unordered_map<std::string_view, float>
+Classification::postprocess(const Tensor &tensor) {
+  std::span<const float> resultData(
+      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()) {
+    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());
+    throw std::runtime_error(errorMessage);
+  }
+
+  numerical::softmax(resultVec);
+
+  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];
+  }
+
+  return probs;
+}
+
+} // namespace rnexecutorch

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <unordered_map>
+
+#include <executorch/extension/tensor/tensor_ptr.h>
+#include <opencv2/opencv.hpp>
+
+#include <rnexecutorch/models/BaseModel.h>
+
+namespace rnexecutorch {
+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 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 {
+inline constexpr std::array<std::string_view, 1000> IMAGENET1K_V1_LABELS = {
     "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

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

@@ -0,0 +1,27 @@
+#include "BaseEmbeddings.h"
+
+#include <span>
+
+namespace rnexecutorch {
+
+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 dataPtr = forwardResultTensor.mutable_data_ptr();
+  auto outputNumel = forwardResultTensor.numel();
+
+  std::span<float> modelOutput(static_cast<float *>(dataPtr), outputNumel);
+
+  auto createBuffer = [](const auto &data, size_t size) {
+    auto buffer = std::make_shared<OwningArrayBuffer>(size);
+    std::memcpy(buffer->data(), data, size);
+    return buffer;
+  };
+  return createBuffer(modelOutput.data(), modelOutput.size_bytes());
+}
+
+} // namespace rnexecutorch

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

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <rnexecutorch/models/BaseModel.h>
+
+namespace rnexecutorch {
+
+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

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 {
+
+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] =
+      imageprocessing::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

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

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <executorch/extension/tensor/tensor_ptr.h>
+#include <executorch/runtime/core/evalue.h>
+#include <opencv2/opencv.hpp>
+
+#include <rnexecutorch/models/embeddings/BaseEmbeddings.h>
+
+namespace rnexecutorch {
+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 rnexecutorch

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

@@ -0,0 +1,61 @@
+#include "TextEmbeddings.h"
+#include <executorch/extension/tensor/tensor_ptr_maker.h>
+#include <rnexecutorch/data_processing/Numerical.h>
+
+namespace rnexecutorch {
+
+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

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <rnexecutorch/TokenizerModule.h>
+#include <rnexecutorch/models/embeddings/BaseEmbeddings.h>
+
+namespace rnexecutorch {
+
+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 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 {
+inline constexpr std::array<std::string_view, 21> DEEPLABV3_RESNET50_LABELS = {
     "BACKGROUND", "AEROPLANE",   "BICYCLE", "BIRD",  "BOAT",
     "BOTTLE",     "BUS",         "CAR",     "CAT",   "CHAIR",
     "COW",        "DININGTABLE", "DOG",     "HORSE", "MOTORBIKE",
     "PERSON",     "POTTEDPLANT", "SHEEP",   "SOFA",  "TRAIN",
     "TVMONITOR"};
+} // namespace rnexecutorch