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

package/common/rnexecutorch/data_processing/Numerical.cpp

@@ -0,0 +1,111 @@
+#include "Numerical.h"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <numeric>
+#include <sstream>
+#include <string>
+
+namespace rnexecutorch::numerical {
+
+void softmax(std::span<float> input) {
+  if (input.empty()) {
+    return;
+  }
+
+  const auto maxElement = *std::ranges::max_element(input);
+
+  for (auto &value : input) {
+    value = std::exp(value - maxElement);
+  }
+
+  const auto sum = std::reduce(input.begin(), input.end());
+
+  // sum is at least 1 since exp(max - max) == exp(0) == 1
+  for (auto &value : input) {
+    value /= sum;
+  }
+}
+
+void softmaxWithTemperature(std::span<float> input, float temperature) {
+  if (input.empty()) {
+    return;
+  }
+
+  if (temperature <= 0.0F) {
+    throw std::invalid_argument(
+        "Temperature must be greater than 0 for softmax with temperature.");
+  }
+
+  const auto maxElement = *std::ranges::max_element(input);
+
+  for (auto &value : input) {
+    value = std::exp((value - maxElement) / temperature);
+  }
+
+  const auto sum = std::reduce(input.begin(), input.end());
+
+  // sum is at least 1 since exp(max - max) == exp(0) == 1
+  for (auto &value : input) {
+    value /= sum;
+  }
+}
+
+void normalize(std::span<float> input) {
+  const auto sumOfSquares =
+      std::inner_product(input.begin(), input.end(), input.begin(), 0.0F);
+
+  constexpr auto kEpsilon = 1.0e-15F;
+
+  const auto norm = std::sqrt(sumOfSquares) + kEpsilon;
+
+  for (auto &value : input) {
+    value /= norm;
+  }
+}
+
+std::vector<float> meanPooling(std::span<const float> modelOutput,
+                               std::span<const int64_t> attnMask) {
+  if (attnMask.empty() || modelOutput.size() % attnMask.size() != 0) {
+    std::stringstream ss;
+    ss << "Invalid dimensions for mean pooling, expected model output size to "
+          "be divisible "
+       << "by the size of attention mask but got size: " << modelOutput.size()
+       << " for model output and size: " << attnMask.size()
+       << " for attention mask";
+    throw std::invalid_argument(ss.str());
+  }
+
+  auto attnMaskLength = attnMask.size();
+  auto embeddingDim = modelOutput.size() / attnMaskLength;
+
+  auto maskSum = std::reduce(attnMask.begin(), attnMask.end());
+  std::vector<float> result(embeddingDim, 0.0F);
+  if (maskSum == 0LL) {
+    return result;
+  }
+
+  for (std::size_t i = 0; i < attnMaskLength; ++i) {
+    if (attnMask[i] != 0LL) {
+      for (std::size_t j = 0; j < embeddingDim; ++j) {
+        result[j] += modelOutput[i * embeddingDim + j];
+      }
+    }
+  }
+
+  for (auto &value : result) {
+    value /= static_cast<float>(maskSum);
+  }
+
+  return result;
+}
+
+template <typename T> bool isClose(T a, T b, T atol) {
+  return std::abs(a - b) <= atol;
+}
+
+template bool isClose<float>(float, float, float);
+template bool isClose<double>(double, double, double);
+
+} // namespace rnexecutorch::numerical

package/common/rnexecutorch/data_processing/Numerical.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <span>
+#include <vector>
+
+/**
+ * @namespace rnexecutorch::numerical
+ * @brief Namespace for numerical operations and transformations.
+ */
+namespace rnexecutorch::numerical {
+
+/**
+ * @brief Applies the softmax function in-place to a sequence of numbers.
+ *
+ * @param input A mutable span of floating-point numbers. After the function
+ * returns, `input` contains the softmax probabilities.
+ */
+void softmax(std::span<float> input);
+
+/**
+ * @brief Applies the softmax function with temperature scaling in-place to a
+ * sequence of numbers.
+ *
+ * The temperature parameter controls the "sharpness" of the resulting
+ * probability distribution. A temperature of 1.0 means no scaling, while lower
+ * values make the distribution sharper (more peaked), and higher values make it
+ * softer (more uniform).
+ *
+ * @param input A mutable span of floating-point numbers. After the function
+ * returns, `input` contains the softmax probabilities.
+ * @param temperature A positive float value used to scale the logits before
+ * applying softmax. Must be greater than 0.
+ */
+void softmaxWithTemperature(std::span<float> input, float temperature);
+
+/**
+ * @brief Normalizes the elements of the given float span in-place using the
+ * L2 norm method.
+ *
+ * This function scales the input vector such that its L2 norm (Euclidean norm)
+ * becomes 1. If the norm is zero, the result is a zero vector with the same
+ * size as the input.
+ *
+ * @param input A mutable span of floating-point values representing the data to
+ * be normalized.
+ */
+void normalize(std::span<float> input);
+
+/**
+ * @brief Computes mean pooling across the modelOutput adjusted by an attention
+ * mask.
+ *
+ * This function aggregates the `modelOutput` span by sections defined by
+ * `attnMask`, computing the mean of sections influenced by the mask. The result
+ * is a vector where each element is the mean of a segment from the original
+ * data.
+ *
+ * @param modelOutput A span of floating-point numbers representing the model
+ * output.
+ * @param attnMask A span of integers where each integer is a weight
+ * corresponding to the elements in `modelOutput`.
+ * @return A std::vector<float> containing the computed mean values of segments.
+ */
+std::vector<float> meanPooling(std::span<const float> modelOutput,
+                               std::span<const int64_t> attnMask);
+
+/**
+ * @brief Checks if two floating-point numbers are considered equal.
+ */
+template <typename T>
+bool isClose(T a, T b,
+             T atol = std::numeric_limits<T>::epsilon() * static_cast<T>(10));
+
+extern template bool isClose<float>(float, float, float);
+extern template bool isClose<double>(double, double, double);
+
+} // namespace rnexecutorch::numerical

package/common/rnexecutorch/data_processing/base64.cpp

@@ -0,0 +1,110 @@
+#include "base64.h"
+#include <iostream>
+
+static const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                        "abcdefghijklmnopqrstuvwxyz"
+                                        "0123456789+/";
+
+static inline bool is_base64(BYTE c) {
+  return (isalnum(c) || (c == '+') || (c == '/'));
+}
+
+std::string base64_encode(BYTE const *buf, unsigned int bufLen) {
+  std::string ret;
+  int i = 0;
+  int j = 0;
+  BYTE char_array_3[3];
+  BYTE char_array_4[4];
+
+  while (bufLen--) {
+    char_array_3[i++] = *(buf++);
+    if (i == 3) {
+      char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+      char_array_4[1] =
+          ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+      char_array_4[2] =
+          ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+      char_array_4[3] = char_array_3[2] & 0x3f;
+
+      for (i = 0; (i < 4); i++) {
+        ret += base64_chars[char_array_4[i]];
+      }
+      i = 0;
+    }
+  }
+
+  if (i) {
+    for (j = i; j < 3; j++) {
+      char_array_3[j] = '\0';
+    }
+
+    char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+    char_array_4[1] =
+        ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+    char_array_4[2] =
+        ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+    char_array_4[3] = char_array_3[2] & 0x3f;
+
+    for (j = 0; (j < i + 1); j++) {
+      ret += base64_chars[char_array_4[j]];
+    }
+
+    while ((i++ < 3)) {
+      ret += '=';
+    }
+  }
+
+  return ret;
+}
+
+std::vector<BYTE> base64_decode(std::string const &encoded_string) {
+  int in_len = encoded_string.size();
+  int i = 0;
+  int j = 0;
+  int in_ = 0;
+  BYTE char_array_4[4], char_array_3[3];
+  std::vector<BYTE> ret;
+
+  while (in_len-- && (encoded_string[in_] != '=') &&
+         is_base64(encoded_string[in_])) {
+    char_array_4[i++] = encoded_string[in_];
+    in_++;
+    if (i == 4) {
+      for (i = 0; i < 4; i++) {
+        char_array_4[i] = base64_chars.find(char_array_4[i]);
+      }
+
+      char_array_3[0] =
+          (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+      char_array_3[1] =
+          ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+      for (i = 0; (i < 3); i++) {
+        ret.push_back(char_array_3[i]);
+      }
+      i = 0;
+    }
+  }
+
+  if (i) {
+    for (j = i; j < 4; j++) {
+      char_array_4[j] = 0;
+    }
+
+    for (j = 0; j < 4; j++) {
+      char_array_4[j] = base64_chars.find(char_array_4[j]);
+    }
+
+    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+    char_array_3[1] =
+        ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+    for (j = 0; (j < i - 1); j++) {
+      ret.push_back(char_array_3[j]);
+    }
+  }
+
+  return ret;
+}

package/common/rnexecutorch/data_processing/base64.h

@@ -0,0 +1,46 @@
+/*
+   base64.cpp and base64.h
+
+   base64 encoding and decoding with C++.
+   More information at
+     https://renenyffenegger.ch/notes/development/Base64/Encoding-and-decoding-base-64-with-cpp
+
+   Version: 2.rc.09 (release candidate)
+
+   Copyright (C) 2004-2017, 2020-2022 René Nyffenegger
+
+   This source code is provided 'as-is', without any express or implied
+   warranty. In no event will the author be held liable for any damages
+   arising from the use of this software.
+
+   Permission is granted to anyone to use this software for any purpose,
+   including commercial applications, and to alter it and redistribute it
+   freely, subject to the following restrictions:
+
+   1. The origin of this source code must not be misrepresented; you must not
+      claim that you wrote the original source code. If you use this source code
+      in a product, an acknowledgment in the product documentation would be
+      appreciated but is not required.
+
+   2. Altered source versions must be plainly marked as such, and must not be
+      misrepresented as being the original source code.
+
+   3. This notice may not be removed or altered from any source distribution.
+
+   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
+
+*/
+
+// Modified version by LihO at https://stackoverflow.com/a/13935718/7470700
+
+#ifndef _BASE64_H_
+#define _BASE64_H_
+
+#include <string>
+#include <vector>
+typedef unsigned char BYTE;
+
+std::string base64_encode(BYTE const *buf, unsigned int bufLen);
+std::vector<BYTE> base64_decode(std::string const &);
+
+#endif

package/common/rnexecutorch/data_processing/dsp.cpp

@@ -0,0 +1,19 @@
+#include <cstddef>
+#include <math.h>
+#include <rnexecutorch/data_processing/FFT.h>
+#include <rnexecutorch/data_processing/dsp.h>
+
+namespace rnexecutorch::dsp {
+
+using namespace rnexecutorch::dsp;
+
+std::vector<float> hannWindow(size_t size) {
+  // https://www.mathworks.com/help/signal/ref/hann.html
+  std::vector<float> window(size);
+  for (size_t i = 0; i < size; i++) {
+    window[i] = 0.5f * (1 - std::cos(2 * M_PI * i / size));
+  }
+  return window;
+}
+
+} // namespace rnexecutorch::dsp

package/common/rnexecutorch/data_processing/dsp.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <span>
+#include <vector>
+
+namespace rnexecutorch::dsp {
+
+std::vector<float> hannWindow(size_t size);
+std::vector<float> stftFromWaveform(std::span<const float> waveform,
+                                    size_t fftWindowSize, size_t hopSize);
+
+} // namespace rnexecutorch::dsp

package/common/rnexecutorch/data_processing/gzip.cpp

@@ -0,0 +1,47 @@
+#include <vector>
+#include <zlib.h>
+
+#include "gzip.h"
+
+namespace rnexecutorch::gzip {
+
+namespace {
+constexpr int32_t kGzipWrapper = 16;     // gzip header/trailer
+constexpr int32_t kMemLevel = 8;         // memory level
+constexpr size_t kChunkSize = 16 * 1024; // 16 KiB stream buffer
+} // namespace
+
+size_t deflateSize(const std::string &input) {
+  z_stream strm{};
+  if (::deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
+                     MAX_WBITS + kGzipWrapper, kMemLevel,
+                     Z_DEFAULT_STRATEGY) != Z_OK) {
+    throw std::runtime_error("deflateInit2 failed");
+  }
+
+  size_t outSize = 0;
+
+  strm.next_in = reinterpret_cast<z_const Bytef *>(
+      const_cast<z_const char *>(input.data()));
+  strm.avail_in = static_cast<uInt>(input.size());
+
+  std::vector<unsigned char> buf(kChunkSize);
+  int ret;
+  do {
+    strm.next_out = buf.data();
+    strm.avail_out = static_cast<uInt>(buf.size());
+
+    ret = ::deflate(&strm, strm.avail_in ? Z_NO_FLUSH : Z_FINISH);
+    if (ret == Z_STREAM_ERROR) {
+      ::deflateEnd(&strm);
+      throw std::runtime_error("deflate stream error");
+    }
+
+    outSize += buf.size() - strm.avail_out;
+  } while (ret != Z_STREAM_END);
+
+  ::deflateEnd(&strm);
+  return outSize;
+}
+
+} // namespace rnexecutorch::gzip

package/common/rnexecutorch/data_processing/gzip.h

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace rnexecutorch::gzip {
+
+size_t deflateSize(const std::string &input);
+
+} // namespace rnexecutorch::gzip

package/common/rnexecutorch/host_objects/JSTensorViewIn.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace rnexecutorch {
+
+using executorch::aten::ScalarType;
+
+struct JSTensorViewIn {
+  void *dataPtr;
+  std::vector<int32_t> sizes;
+  ScalarType scalarType;
+};
+} // namespace rnexecutorch

package/common/rnexecutorch/host_objects/JSTensorViewOut.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <executorch/runtime/core/portable_type/scalar_type.h>
+#include <memory>
+#include <rnexecutorch/jsi/OwningArrayBuffer.h>
+#include <vector>
+
+namespace rnexecutorch {
+
+using executorch::runtime::etensor::ScalarType;
+
+struct JSTensorViewOut {
+  std::shared_ptr<OwningArrayBuffer> dataPtr;
+  std::vector<int32_t> sizes;
+  ScalarType scalarType;
+
+  JSTensorViewOut(std::vector<int32_t> sizes, ScalarType scalarType,
+                  std::shared_ptr<OwningArrayBuffer> dataPtr)
+      : dataPtr(std::move(dataPtr)), sizes(std::move(sizes)),
+        scalarType(scalarType) {}
+};
+} // namespace rnexecutorch