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

package/common/rnexecutorch/jsi/RuntimeAwareCache.h

@@ -0,0 +1,58 @@
+#pragma once
+// Adapted from https://github.com/software-mansion/react-native-audio-api
+
+// Header in jsi/ need to be added like this. See comment in JsiHostObject.h.
+#include <rnexecutorch/jsi/RuntimeLifecycleMonitor.h>
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <unordered_map>
+#include <utility>
+
+namespace rnexecutorch {
+
+using namespace facebook;
+
+/**
+ * Provides a way to keep data specific to a jsi::Runtime instance that gets
+ * cleaned up when that runtime is destroyed. This is necessary because JSI does
+ * not allow for its associated objects to be retained past the runtime
+ * lifetime. If an object (e.g. jsi::Values or jsi::Function instances) is kept
+ * after the runtime is torn down, its destructor (once it is destroyed
+ * eventually) will result in a crash (JSI objects keep a pointer to memory
+ * managed by the runtime, accessing that portion of the memory after runtime is
+ * deleted is the root cause of that crash).
+ */
+template <typename T>
+class RuntimeAwareCache : public RuntimeLifecycleListener {
+public:
+  void onRuntimeDestroyed(jsi::Runtime *rt) override {
+    // A runtime has been destroyed, so destroy the related cache.
+    runtimeCaches_.erase(rt);
+  }
+
+  ~RuntimeAwareCache() override {
+    for (auto &cache : runtimeCaches_) {
+      // remove all `onRuntimeDestroyed` listeners.
+      RuntimeLifecycleMonitor::removeListener(*cache.first, this);
+    }
+  }
+
+  T &get(jsi::Runtime &rt) {
+    if (runtimeCaches_.count(&rt) == 0) {
+      // This is the first time this Runtime has been accessed.
+      // We set up a `onRuntimeDestroyed` listener for it and
+      // initialize the cache map.
+      RuntimeLifecycleMonitor::addListener(rt, this);
+
+      T cache;
+      runtimeCaches_.emplace(&rt, std::move(cache));
+    }
+    return runtimeCaches_.at(&rt);
+  }
+
+private:
+  std::unordered_map<jsi::Runtime *, T> runtimeCaches_;
+};
+
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/RuntimeLifecycleMonitor.cpp

@@ -0,0 +1,53 @@
+#include "RuntimeLifecycleMonitor.h"
+
+namespace rnexecutorch {
+
+static std::unordered_map<jsi::Runtime *,
+                          std::unordered_set<RuntimeLifecycleListener *>>
+    listeners;
+
+struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
+  jsi::Runtime *rt_;
+  explicit RuntimeLifecycleMonitorObject(jsi::Runtime *rt) : rt_(rt) {}
+  ~RuntimeLifecycleMonitorObject() override {
+    auto listenersSet = listeners.find(rt_);
+    if (listenersSet != listeners.end()) {
+      for (auto listener : listenersSet->second) {
+        listener->onRuntimeDestroyed(rt_);
+      }
+      listeners.erase(listenersSet);
+    }
+  }
+};
+
+void RuntimeLifecycleMonitor::addListener(jsi::Runtime &rt,
+                                          RuntimeLifecycleListener *listener) {
+  auto listenersSet = listeners.find(&rt);
+  if (listenersSet == listeners.end()) {
+    // We install a global host object in the provided runtime, this way we can
+    // use that host object destructor to get notified when the runtime is being
+    // terminated. We use a unique name for the object as it gets saved with the
+    // runtime's global object.
+    rt.global().setProperty(
+        rt, "__rnaudioapi_runtime_lifecycle_monitor",
+        jsi::Object::createFromHostObject(
+            rt, std::make_shared<RuntimeLifecycleMonitorObject>(&rt)));
+    std::unordered_set<RuntimeLifecycleListener *> newSet;
+    newSet.insert(listener);
+    listeners.emplace(&rt, std::move(newSet));
+  } else {
+    listenersSet->second.insert(listener);
+  }
+}
+
+void RuntimeLifecycleMonitor::removeListener(
+    jsi::Runtime &rt, RuntimeLifecycleListener *listener) {
+  auto listenersSet = listeners.find(&rt);
+  if (listenersSet == listeners.end()) {
+    // nothing to do here
+  } else {
+    listenersSet->second.erase(listener);
+  }
+}
+
+} // namespace rnexecutorch

package/common/rnexecutorch/jsi/RuntimeLifecycleMonitor.h

@@ -0,0 +1,35 @@
+#pragma once
+// Adapted from https://github.com/software-mansion/react-native-audio-api
+
+#include <jsi/jsi.h>
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+namespace rnexecutorch {
+
+using namespace facebook;
+
+/**
+ * Listener interface that allows for getting notified when a jsi::Runtime
+ * instance is destroyed.
+ */
+struct RuntimeLifecycleListener {
+  virtual ~RuntimeLifecycleListener() = default;
+  virtual void onRuntimeDestroyed(jsi::Runtime *) = 0;
+};
+
+/**
+ * This class provides an API via static methods for registering and
+ * unregistering runtime lifecycle listeners. The listeners can be used to
+ * cleanup any data that references a given jsi::Runtime instance before it gets
+ * destroyed.
+ */
+struct RuntimeLifecycleMonitor {
+  static void addListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener);
+  static void removeListener(jsi::Runtime &rt,
+                             RuntimeLifecycleListener *listener);
+};
+
+} // namespace rnexecutorch

package/common/rnexecutorch/metaprogramming/ConstructorHelpers.h

@@ -0,0 +1,133 @@
+#pragma once
+
+#include <concepts>
+#include <jsi/jsi.h>
+#include <memory>
+#include <rnexecutorch/host_objects/JsiConversions.h>
+#include <tuple>
+#include <type_traits>
+
+namespace facebook::react {
+class CallInvoker;
+}
+
+namespace rnexecutorch {
+namespace meta {
+
+using namespace facebook;
+
+/**
+ * To be able to generically invoke constructors, we need to know what types
+ * are the arguments that need to be passed to it. To do this, we specialize the
+ * ConstructorTraits struct template for each class which constructor we want to
+ * use. See REGISTER_CONSTRUCTOR macro for a easy way to do this.
+ *
+ * Note: a downside for this method is that we can specialize ConstructorTraits
+ * only for a single constructor signature per class.
+ */
+
+template <typename T> struct ConstructorTraits;
+
+template <typename T>
+concept HasConstructorTraits =
+    requires { typename ConstructorTraits<T>::arg_types; };
+
+template <typename T, typename Tuple> struct is_constructible_from_tuple;
+
+template <typename T, typename... Args>
+struct is_constructible_from_tuple<T, std::tuple<Args...>>
+    : std::is_constructible<T, Args...> {};
+
+template <typename T, typename Tuple>
+concept ConstructibleFromTuple = is_constructible_from_tuple<T, Tuple>::value;
+
+template <typename NotTuple>
+struct last_element_is_call_invoker : std::false_type {};
+
+template <typename... Args>
+struct last_element_is_call_invoker<std::tuple<Args...>> {
+private:
+  template <typename Last> static constexpr bool check() {
+    return std::is_same_v<Last, std::shared_ptr<facebook::react::CallInvoker>>;
+  }
+
+  template <typename First, typename Second, typename... Rest>
+  static constexpr bool check_last() {
+    return check_last<Second, Rest...>();
+  }
+
+  template <typename Last> static constexpr bool check_last() {
+    return check<Last>();
+  }
+
+public:
+  static constexpr bool value = sizeof...(Args) > 0 && check_last<Args...>();
+};
+
+// HasConstructorTraits<T> could be removed as typename
+// ConstructorTraits<T>::arg_types would still resolve the concept to false if
+// it wouldn't be defined, but we keep it for readability
+template <typename T>
+concept ValidConstructorTraits =
+    HasConstructorTraits<T> &&
+    ConstructibleFromTuple<T, typename ConstructorTraits<T>::arg_types>;
+
+template <typename T>
+concept CallInvokerLastInConstructor =
+    HasConstructorTraits<T> &&
+    last_element_is_call_invoker<
+        typename ConstructorTraits<T>::arg_types>::value;
+
+template <typename... Types, std::size_t... I>
+std::tuple<Types...> fillConstructorTupleFromArgs(
+    std::index_sequence<I...>, const jsi::Value *args, jsi::Runtime &runtime,
+    std::shared_ptr<react::CallInvoker> jsCallInvoker) {
+  constexpr std::size_t lastIndex = sizeof...(Types) - 1;
+  return std::make_tuple([&]() {
+    if constexpr (I == lastIndex) {
+      return jsCallInvoker;
+    } else {
+      return jsi_conversion::getValue<Types>(args[I], runtime);
+    }
+  }()...);
+}
+
+/// @brief A method that creates a tuple of arguments based on types specified
+/// in a ConstructorTraits specialization. The class has to have CallInvoker as
+/// the last argument in the constructor.
+/// @tparam T The class for which we want to construct the tuple
+/// @param args JSI args passed from JS that will be converted according to
+/// getValue<T> from JsiConversions
+/// @param runtime JS runtime reference
+/// @param jsCallInvoker CallInvoker that will be passed to the constructed
+/// object. This is the only argument that is not created from jsi::Value.
+/// @return A tuple which can then be used to instantiate the class T.
+template <typename T>
+  requires ValidConstructorTraits<T> && CallInvokerLastInConstructor<T>
+auto createConstructorArgsWithCallInvoker(
+    const jsi::Value *args, jsi::Runtime &runtime,
+    std::shared_ptr<react::CallInvoker> jsCallInvoker) {
+  return std::apply(
+      [&](auto... typeWrappers) {
+        return fillConstructorTupleFromArgs<decltype(typeWrappers)...>(
+            std::index_sequence_for<decltype(typeWrappers)...>{}, args, runtime,
+            jsCallInvoker);
+      },
+      typename ConstructorTraits<T>::arg_types{});
+}
+
+} // namespace meta
+
+/**
+ * @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, ...)                                       \
+  template <> struct meta::ConstructorTraits<Class> {                          \
+    using arg_types = std::tuple<__VA_ARGS__>;                                 \
+  }
+
+} // namespace rnexecutorch

package/common/rnexecutorch/metaprogramming/FunctionHelpers.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <cstddef>
+#include <jsi/jsi.h>
+#include <tuple>
+
+#include <rnexecutorch/host_objects/JsiConversions.h>
+
+namespace rnexecutorch::meta {
+using namespace facebook;
+
+template <typename Model, typename R, typename... Types>
+constexpr std::size_t getArgumentCount(R (Model::*f)(Types...)) {
+  return sizeof...(Types);
+}
+
+template <typename Model, typename R, typename... Types>
+constexpr std::size_t getArgumentCount(R (Model::*f)(Types...) const) {
+  return sizeof...(Types);
+}
+
+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(jsi_conversion::getValue<Types>(args[I], runtime)...);
+}
+
+/**
+ * createArgsTupleFromJsi creates a tuple that can be used as a collection of
+ * arguments for method supplied with a pointer. The types in the tuple are
+ * inferred from the method pointer.
+ */
+
+template <typename Model, typename R, typename... Types>
+std::tuple<Types...> createArgsTupleFromJsi(R (Model::*f)(Types...),
+                                            const jsi::Value *args,
+                                            jsi::Runtime &runtime) {
+  return fillTupleFromArgs<Types...>(std::index_sequence_for<Types...>{}, args,
+                                     runtime);
+}
+
+template <typename Model, typename R, typename... Types>
+std::tuple<Types...> createArgsTupleFromJsi(R (Model::*f)(Types...) const,
+                                            const jsi::Value *args,
+                                            jsi::Runtime &runtime) {
+  return fillTupleFromArgs<Types...>(std::index_sequence_for<Types...>{}, args,
+                                     runtime);
+}
+} // namespace rnexecutorch::meta

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,183 @@
+#include "BaseModel.h"
+
+#include <executorch/extension/tensor/tensor.h>
+#include <filesystem>
+#include <stdexcept>
+
+namespace rnexecutorch::models {
+
+using namespace facebook;
+using namespace executorch::extension;
+using ::executorch::extension::module::Module;
+using ::executorch::runtime::Error;
+
+BaseModel::BaseModel(const std::string &modelSource,
+                     std::shared_ptr<react::CallInvoker> callInvoker,
+                     Module::LoadMode loadMode)
+    : callInvoker(callInvoker),
+      module_(std::make_unique<Module>(modelSource, loadMode)) {
+  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) const {
+  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) const {
+  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) const {
+  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>(
+        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) const {
+  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) const {
+  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) const {
+  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) const {
+  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) const {
+  auto sizes = tensor.sizes();
+  return std::vector<int32_t>(sizes.begin(), sizes.end());
+}
+
+} // namespace rnexecutorch::models

package/common/rnexecutorch/models/BaseModel.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
+#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 {
+namespace models {
+using namespace facebook;
+using executorch::extension::module::Module;
+using executorch::runtime::EValue;
+using executorch::runtime::Result;
+
+class BaseModel {
+public:
+  BaseModel(
+      const std::string &modelSource,
+      std::shared_ptr<react::CallInvoker> callInvoker,
+      Module::LoadMode loadMode = Module::LoadMode::MmapUseMlockIgnoreErrors);
+  std::size_t getMemoryLowerBound() const noexcept;
+  void unload() noexcept;
+  std::vector<int32_t> getInputShape(std::string method_name,
+                                     int32_t index) const;
+  std::vector<std::vector<int32_t>>
+  getAllInputShapes(std::string methodName = "forward") const;
+  std::vector<JSTensorViewOut>
+  forwardJS(std::vector<JSTensorViewIn> tensorViewVec) const;
+  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) const;
+  Result<executorch::runtime::MethodMeta>
+  getMethodMeta(const std::string &methodName) const;
+
+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_;
+
+  std::size_t memorySizeLowerBound{0};
+
+private:
+  std::vector<int32_t>
+  getTensorShape(const executorch::aten::Tensor &tensor) const;
+};
+} // namespace models
+
+REGISTER_CONSTRUCTOR(models::BaseModel, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+} // 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::models::classification {
+
+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 =
+      image_processing::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() != constants::kImagenet1kV1Labels.size()) {
+    char errorMessage[100];
+    std::snprintf(
+        errorMessage, sizeof(errorMessage),
+        "Unexpected classification output size, was expecting: %zu classes "
+        "but got: %zu classes",
+        constants::kImagenet1kV1Labels.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[constants::kImagenet1kV1Labels[cl]] = resultVec[cl];
+  }
+
+  return probs;
+}
+
+} // namespace rnexecutorch::models::classification