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

package/common/runner/sampler.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <cctype>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <memory>
+#ifdef USE_ATEN_LIB
+#include <torch/torch.h>
+#endif
+
+#include <executorch/runtime/core/exec_aten/exec_aten.h>
+#include <executorch/runtime/platform/compiler.h>
+
+namespace executorch {
+namespace extension {
+namespace llm {
+// A simple llama2 sampler.
+
+template <typename T> struct ProbIndex {
+  T prob;
+  int32_t index;
+}; // struct used when sorting probabilities during top-p sampling
+
+class Sampler {
+public:
+  Sampler(int32_t vocab_size, float temperature, float topp,
+          unsigned long long rng_seed);
+
+  Sampler(int32_t vocab_size, float temperature, float topp);
+
+  template <typename T> int32_t sample(T *logits);
+
+private:
+  template <typename T> int32_t sample_topp(T *probabilities, float coin);
+  template <typename T> int32_t sample_mult(T *probabilities, float coin);
+  template <typename T> int32_t sample_argmax(T *probabilities);
+
+private:
+  int32_t vocab_size_;
+  // reciprocal of temperature, or 0 if temperature == 0.
+  float inv_temperature_;
+  float topp_;
+  unsigned long long rng_state_;
+};
+
+} // namespace llm
+} // namespace extension
+} // namespace executorch
+
+namespace torch {
+namespace executor {
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces.
+using ::executorch::extension::llm::ProbIndex;
+using ::executorch::extension::llm::Sampler;
+} // namespace executor
+} // namespace torch

package/common/runner/stats.h

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Runner stats for LLM
+#pragma once
+#include "util.h"
+#include <cinttypes>
+#include <executorch/runtime/platform/log.h>
+#include <sstream>
+#include <string>
+
+namespace executorch {
+namespace extension {
+namespace llm {
+
+struct Stats {
+  // Scaling factor for timestamps - in this case, we use ms.
+  const long SCALING_FACTOR_UNITS_PER_SECOND = 1000;
+  // Time stamps for the different stages of the execution
+  // model_load_start_ms: Start of model loading.
+  long model_load_start_ms;
+  // model_load_end_ms: End of model loading.
+  long model_load_end_ms;
+  // inference_start_ms: Immediately after the model is loaded (or we check
+  // for model load), measure the inference time.
+  // NOTE: It's actually the tokenizer encode + model execution time.
+  long inference_start_ms;
+  // End of the tokenizer encode time.
+  long token_encode_end_ms;
+  // Start of the model execution (forward function) time.
+  long model_execution_start_ms;
+  // End of the model execution (forward function) time.
+  long model_execution_end_ms;
+  // prompt_eval_end_ms: Prompt array allocation and tokenization. Ends right
+  // before the inference loop starts
+  long prompt_eval_end_ms;
+  // first_token: Timestamp when the first generated token is emitted
+  long first_token_ms;
+  // inference_end_ms: End of inference/generation.
+  long inference_end_ms;
+  // Keep a running total of the time spent in sampling.
+  long aggregate_sampling_time_ms;
+  // Token count from prompt
+  int64_t num_prompt_tokens;
+  // Token count from generated (total - prompt)
+  int64_t num_generated_tokens;
+  inline void on_sampling_begin() {
+    aggregate_sampling_timer_start_timestamp = time_in_ms();
+  }
+  inline void on_sampling_end() {
+    aggregate_sampling_time_ms +=
+        time_in_ms() - aggregate_sampling_timer_start_timestamp;
+    aggregate_sampling_timer_start_timestamp = 0;
+  }
+
+  void reset(bool all_stats = false) {
+    // Not resetting model_load_start_ms and model_load_end_ms because reset is
+    // typically called after warmup and before running the actual run.
+    // However, we don't load the model again during the actual run after
+    // warmup. So, we don't want to reset these timestamps unless we are
+    // resetting everything.
+    if (all_stats) {
+      model_load_start_ms = 0;
+      model_load_end_ms = 0;
+    }
+    inference_start_ms = 0;
+    prompt_eval_end_ms = 0;
+    first_token_ms = 0;
+    inference_end_ms = 0;
+    aggregate_sampling_time_ms = 0;
+    num_prompt_tokens = 0;
+    num_generated_tokens = 0;
+    aggregate_sampling_timer_start_timestamp = 0;
+  }
+
+private:
+  long aggregate_sampling_timer_start_timestamp = 0;
+};
+
+inline std::string stats_to_json_string(const Stats &stats) {
+  std::stringstream ss;
+  ss << "{\"prompt_tokens\":" << stats.num_prompt_tokens << ","
+     << "\"generated_tokens\":" << stats.num_generated_tokens << ","
+     << "\"model_load_start_ms\":" << stats.model_load_start_ms << ","
+     << "\"model_load_end_ms\":" << stats.model_load_end_ms << ","
+     << "\"inference_start_ms\":" << stats.inference_start_ms << ","
+     << "\"inference_end_ms\":" << stats.inference_end_ms << ","
+     << "\"prompt_eval_end_ms\":" << stats.prompt_eval_end_ms << ","
+     << "\"first_token_ms\":" << stats.first_token_ms << ","
+     << "\"aggregate_sampling_time_ms\":" << stats.aggregate_sampling_time_ms
+     << "," << "\"SCALING_FACTOR_UNITS_PER_SECOND\":"
+     << stats.SCALING_FACTOR_UNITS_PER_SECOND << "}";
+  return ss.str();
+}
+
+inline void print_report(const Stats &stats) {
+  printf("PyTorchObserver %s\n", stats_to_json_string(stats).c_str());
+
+  ET_LOG(Info, "\tPrompt Tokens: %" PRIu64 "    Generated Tokens: %" PRIu64,
+         stats.num_prompt_tokens, stats.num_generated_tokens);
+
+  ET_LOG(Info, "\tModel Load Time:\t\t%f (seconds)",
+         ((double)(stats.model_load_end_ms - stats.model_load_start_ms) /
+          stats.SCALING_FACTOR_UNITS_PER_SECOND));
+  double inference_time_ms =
+      (double)(stats.inference_end_ms - stats.inference_start_ms);
+  ET_LOG(
+      Info,
+      "\tTotal inference time:\t\t%f (seconds)\t\t Rate: \t%f (tokens/second)",
+      inference_time_ms / stats.SCALING_FACTOR_UNITS_PER_SECOND,
+
+      (stats.num_generated_tokens) /
+          (double)(stats.inference_end_ms - stats.inference_start_ms) *
+          stats.SCALING_FACTOR_UNITS_PER_SECOND);
+  double prompt_eval_time =
+      (double)(stats.prompt_eval_end_ms - stats.inference_start_ms);
+  ET_LOG(Info,
+         "\t\tPrompt evaluation:\t%f (seconds)\t\t Rate: \t%f (tokens/second)",
+         prompt_eval_time / stats.SCALING_FACTOR_UNITS_PER_SECOND,
+         (stats.num_prompt_tokens) / prompt_eval_time *
+             stats.SCALING_FACTOR_UNITS_PER_SECOND);
+
+  double eval_time =
+      (double)(stats.inference_end_ms - stats.prompt_eval_end_ms);
+  ET_LOG(Info,
+         "\t\tGenerated %" PRIu64
+         " tokens:\t%f (seconds)\t\t Rate: \t%f (tokens/second)",
+         stats.num_generated_tokens,
+         eval_time / stats.SCALING_FACTOR_UNITS_PER_SECOND,
+         stats.num_generated_tokens / eval_time *
+             stats.SCALING_FACTOR_UNITS_PER_SECOND);
+
+  // Time to first token is measured from the start of inference, excluding
+  // model load time.
+  ET_LOG(Info, "\tTime to first generated token:\t%f (seconds)",
+         ((double)(stats.first_token_ms - stats.inference_start_ms) /
+          stats.SCALING_FACTOR_UNITS_PER_SECOND));
+
+  ET_LOG(Info, "\tSampling time over %" PRIu64 " tokens:\t%f (seconds)",
+         stats.num_prompt_tokens + stats.num_generated_tokens,
+         (double)stats.aggregate_sampling_time_ms /
+             stats.SCALING_FACTOR_UNITS_PER_SECOND);
+}
+
+} // namespace llm
+} // namespace extension
+} // namespace executorch
+
+namespace executorch {
+namespace llm {
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces.
+using ::executorch::extension::llm::print_report;
+using ::executorch::extension::llm::Stats;
+} // namespace llm
+} // namespace executorch

package/common/runner/text_decoder_runner.cpp

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Given inputs, run a text decoder and return logits.
+
+#include "text_decoder_runner.h"
+#include "arange_util.h"
+#include "stats.h"
+
+#include <ctime>
+
+namespace executorch {
+namespace extension {
+namespace llm {
+
+// NOTE: we observed ~2x loading performance increase on iPhone 15
+// and a ~5% improvement on Galaxy S22 by switching to
+// FileDataLoader instead of MmapDataLoader + UseMlockIgnoreErrors.
+TextDecoderRunner::TextDecoderRunner(Module *module, IOManager *io_manager,
+                                     float temperature, float topp)
+    : module_(module), io_manager_(io_manager), temperature_(temperature),
+      topp_(topp) {}
+
+// This function is functional, meaning it shouldn't modify any state of the
+// input. It should be safe to call multiple times with the same inputs. The
+// outer loop (call site) is responsible for managing state.
+::executorch::runtime::Result<executorch::aten::Tensor>
+TextDecoderRunner::step(TensorPtr &tokens, int64_t start_pos) {
+  // ET_LOG(Info, "Input token %" PRIu64, input_token);
+  auto method_meta = ET_UNWRAP(module_->method_meta("forward"));
+  // If only 1 input, we are not using kv cache
+  bool use_kv_cache = method_meta.num_inputs() > 1;
+
+  std::vector<int64_t> cache_positions;
+
+  if (use_kv_cache) {
+    auto start_pos_tensor = ET_UNWRAP(populate_start_pos_or_cache_position(
+        module_, start_pos, cache_positions, tokens->numel(), "forward"));
+
+    std::vector<runtime::EValue> inputs;
+    auto inputs_res = io_manager_->prepare_decode(tokens, start_pos_tensor);
+    ET_CHECK_OK_OR_RETURN_ERROR(inputs_res.error());
+    inputs = inputs_res.get();
+    auto outputs_res = module_->forward(inputs);
+    ET_CHECK_OK_OR_RETURN_ERROR(outputs_res.error());
+
+    auto update_err = io_manager_->update_decode(outputs_res.get());
+    ET_CHECK_OK_OR_RETURN_ERROR(update_err);
+
+    ET_CHECK_MSG(outputs_res.get().size() == 1,
+                 "More then one output returned from executing LLM.");
+    ET_CHECK_MSG(outputs_res.get()[0].isTensor(),
+                 "Non Tensor Output returned from executing LLM");
+
+    // Return the logits tensor
+    return outputs_res.get()[0].toTensor();
+  } else {           // no kv cache
+    (void)start_pos; // unused
+
+    auto outputs_res = module_->forward(tokens);
+    ET_CHECK_OK_OR_RETURN_ERROR(outputs_res.error());
+    ET_CHECK_MSG(outputs_res.get().size() == 1,
+                 "More then one output returned from executing LLM.");
+    ET_CHECK_MSG(outputs_res.get()[0].isTensor(),
+                 "Non Tensor Output returned from executing LLM");
+
+    // Return the logits tensor
+    return outputs_res.get()[0].toTensor();
+  }
+}
+
+} // namespace llm
+} // namespace extension
+} // namespace executorch

package/common/runner/text_decoder_runner.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Given inputs, run a text decoder in LLM and return the output.
+
+#pragma once
+
+#include "io_manager.h"
+#include "sampler.h"
+
+namespace executorch {
+namespace extension {
+namespace llm {
+
+class TextDecoderRunner {
+public:
+  explicit TextDecoderRunner(Module *module, IOManager *io_manager,
+                             float temperature = 0.8F, float topp = 0.9F);
+
+  virtual ~TextDecoderRunner() = default;
+
+  /**
+   * Run LLM text decoder with inputs to generate next token.
+   * @param input The input to the LLM Module.
+   * @param start_pos The starting position in KV cache of the input in the LLM
+   * Module.
+   * @return The output of the LLM Module. This will be a tensor of logits.
+   */
+  virtual ::executorch::runtime::Result<executorch::aten::Tensor>
+  step(TensorPtr &input, int64_t start_pos);
+
+  /**
+   * Load the Module for text decode purpose.
+   * @return The error code.
+   */
+  virtual ::executorch::runtime::Error load() {
+    return module_->load_method("forward");
+  }
+
+  /**
+   * Check if the required methods in the Module is loaded.
+   * @return True if the Module is loaded, false otherwise.
+   */
+  virtual bool is_method_loaded() {
+    return module_->is_method_loaded("forward");
+  }
+
+  virtual void set_temperature(float temperature) noexcept {
+    temperature_ = temperature;
+  }
+
+  virtual void set_topp(float topp) noexcept { topp_ = topp; }
+
+  inline void stop() { should_stop_ = true; }
+
+  /**
+   * Sample the next token from the logits tensor.
+   * @param logits_tensor The logits tensor.
+   * @param temperature The temperature parameter used to control randomness in
+   * sampling.
+   * @return The next token.
+   */
+  inline int32_t logits_to_token(const executorch::aten::Tensor &logits_tensor,
+                                 float temperature = -1.F, float topp = -1.F) {
+    int32_t result = 0;
+
+    temperature = temperature < 0.F ? temperature_ : temperature;
+    topp = topp < 0.F ? topp_ : topp;
+
+    // Create a minimal context for error handling in ET_SWITCH
+    struct {
+      [[noreturn]] void fail(torch::executor::Error /* error */) {
+        ET_CHECK_MSG(false, "Unsupported dtype in logits_to_token");
+      }
+    } ctx;
+
+    ET_SWITCH_FOUR_TYPES(
+        Float, Half, BFloat16, UInt16, logits_tensor.scalar_type(), ctx,
+        "logits_to_token", CTYPE, [&]() {
+          // If the logit_tensor rank is 3, the shape is [batch, seq_length,
+          // vocab_size], get the last logits, sample and return. Else the model
+          // outputs the last logit, directly sample and return.
+          auto *logits = logits_tensor.mutable_data_ptr<CTYPE>();
+          ssize_t vocab_size = logits_tensor.size(logits_tensor.dim() - 1);
+          if (logits_tensor.dim() == 3) {
+            auto num_tokens = logits_tensor.size(1);
+            logits += (num_tokens - 1) * vocab_size;
+          }
+          // @lint-ignore CLANGTIDY facebook-hte-Deprecated
+          Sampler sampler(vocab_size, temperature, topp);
+          result = sampler.sample(logits);
+        });
+    return result;
+  }
+
+protected:
+  /**
+   * Note: TextDecoderRunner does not own the Module or IOManager instance. It
+   * is expected that the outer class (likely Runner) manages the lifecycle of
+   * them. This means that the responsibility for creating, maintaining, and
+   * destroying the Module lies outside of TextDecoderRunner. Ensure that the
+   * Module remains valid for the duration of TextDecoderRunner's usage.
+   */
+  Module *module_;
+  IOManager *io_manager_;
+  bool should_stop_{false};
+  float temperature_;
+  float topp_;
+};
+
+} // namespace llm
+} // namespace extension
+} // namespace executorch
+
+namespace torch {
+namespace executor {
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces.
+using ::executorch::extension::llm::TextDecoderRunner;
+} // namespace executor
+} // namespace torch

package/common/runner/text_prefiller.cpp

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Given a text prompt, encode it using tokenizer and prefill the KV cache of a
+// LLM.
+
+#include "text_prefiller.h"
+#include <algorithm>
+
+namespace executorch {
+namespace extension {
+namespace llm {
+
+TextPrefiller::TextPrefiller(TextDecoderRunner *text_decoder_runner,
+                             bool use_kv_cache, bool enable_parallel_prefill,
+                             int64_t max_seq_len)
+    : text_decoder_runner_(text_decoder_runner), use_kv_cache_(use_kv_cache),
+      enable_parallel_prefill_(enable_parallel_prefill),
+      max_seq_len_(max_seq_len > 0 ? max_seq_len : 128) {}
+
+::executorch::runtime::Result<uint64_t>
+TextPrefiller::prefill(std::vector<uint64_t> &prompt_tokens,
+                       int64_t &start_pos) {
+  ET_CHECK_MSG(!prompt_tokens.empty(), "Prompt cannot be null");
+  if (!text_decoder_runner_->is_method_loaded()) {
+    ET_CHECK_OK_OR_RETURN_ERROR(text_decoder_runner_->load());
+  }
+
+  // Check if we need to chunk the prompt tokens
+  int32_t num_prompt_tokens = prompt_tokens.size();
+
+  // If prompt tokens exceed max_seq_len_, we need to chunk them
+  if (num_prompt_tokens > max_seq_len_) {
+    uint64_t cur_token = 0;
+    int num_tokens_to_process = 0;
+
+    while (num_tokens_to_process < num_prompt_tokens) {
+      auto num_tokens_to_prefill_with = std::min<int>(
+          num_prompt_tokens - num_tokens_to_process, max_seq_len_);
+
+      std::vector<uint64_t> prompt_tokens_to_process(
+          num_tokens_to_prefill_with);
+      std::copy(prompt_tokens.begin() + num_tokens_to_process,
+                prompt_tokens.begin() + num_tokens_to_process +
+                    num_tokens_to_prefill_with,
+                prompt_tokens_to_process.begin());
+
+      // Process this chunk
+      auto chunk_result = prefill_chunk(prompt_tokens_to_process, start_pos);
+      ET_CHECK_OK_OR_RETURN_ERROR(chunk_result.error());
+      cur_token = chunk_result.get();
+
+      num_tokens_to_process += num_tokens_to_prefill_with;
+    }
+
+    return cur_token;
+  } else {
+    // If prompt tokens don't exceed max_seq_len_, process them directly
+    return prefill_chunk(prompt_tokens, start_pos);
+  }
+}
+
+::executorch::runtime::Result<uint64_t>
+TextPrefiller::prefill_chunk(std::vector<uint64_t> &prompt_tokens,
+                             int64_t &start_pos) {
+  // enable_parallel_prefill_ maybe set even when not using kv cache
+  // When kv cache is not used, start pos is ignored
+  int32_t num_prompt_tokens = prompt_tokens.size();
+
+  // store the token
+  uint64_t cur_token;
+  if (enable_parallel_prefill_ || !use_kv_cache_) {
+    // initialize tensor wrappers
+    auto tokens = from_blob(prompt_tokens.data(), {1, num_prompt_tokens},
+                            executorch::aten::ScalarType::Long);
+
+    auto outputs_res = text_decoder_runner_->step(tokens, start_pos);
+
+    ET_CHECK_OK_OR_RETURN_ERROR(outputs_res.error());
+    ET_LOG(Info, "Prefill token result numel(): %zu",
+           outputs_res.get().numel());
+
+    start_pos += num_prompt_tokens;
+    cur_token = text_decoder_runner_->logits_to_token(outputs_res.get());
+  } else {           // sequential prefill
+    int64_t pos = 0; // position in the sequence
+    // NOLINTNEXTLINE(facebook-hte-ParameterUncheckedArrayBounds)
+    cur_token = prompt_tokens[0];
+
+    // initialize tensor wrappers
+    auto tokens =
+        from_blob(&cur_token, {1, 1}, executorch::aten::ScalarType::Long);
+
+    // run the first token and get back logits tensor. Assuming the first token
+    // is bos so don't callback.
+    auto logits_tensor =
+        ET_UNWRAP(text_decoder_runner_->step(tokens, start_pos));
+
+    pos += 1; // start the loop from index 1
+    start_pos += 1;
+
+    while (pos < num_prompt_tokens) {
+      // Run the model
+      // NOLINTNEXTLINE(facebook-hte-ParameterUncheckedArrayBounds)
+      cur_token = prompt_tokens[pos];
+
+      logits_tensor = ET_UNWRAP(text_decoder_runner_->step(tokens, start_pos));
+
+      pos++;
+      start_pos++;
+    }
+
+    cur_token = text_decoder_runner_->logits_to_token(logits_tensor);
+  }
+  return cur_token;
+}
+
+} // namespace llm
+} // namespace extension
+} // namespace executorch

package/common/runner/text_prefiller.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// Given a text prompt, encode it using tokenizer and prefill the KV cache of a
+// LLM.
+
+#pragma once
+
+#include "text_decoder_runner.h"
+
+namespace executorch {
+namespace extension {
+namespace llm {
+
+class TextPrefiller {
+public:
+  TextPrefiller(TextDecoderRunner *text_decoder_runner, bool use_kv_cache,
+                bool enable_parallel_prefill, int64_t max_seq_len = 128);
+
+  virtual ~TextPrefiller() = default;
+  /**
+   * Prefill an LLM Module with the given text input.
+   * @param prompt_tokens The text prompt tokens to the LLM Module. Encoded by
+   * tokenizer.
+   * @param start_pos The starting position in KV cache of the input in the LLM
+   * Module.
+   * @return The next token of the LLM Module after prefill.
+   */
+  virtual ::executorch::runtime::Result<uint64_t>
+  prefill(std::vector<uint64_t> &prompt_tokens, int64_t &start_pos);
+
+  /**
+   * Helper method to prefill a chunk of tokens.
+   * @param prompt_tokens The chunk of text prompt tokens to process.
+   * @param start_pos The starting position in KV cache of the input in the LLM
+   * Module.
+   * @return The next token of the LLM Module after prefilling this chunk.
+   */
+  virtual ::executorch::runtime::Result<uint64_t>
+  prefill_chunk(std::vector<uint64_t> &prompt_tokens, int64_t &start_pos);
+
+  /**
+   * Load the necessary resources for the TextPrefiller.
+   * This method should be called before using the prefill methods.
+   */
+  ::executorch::runtime::Error load() { return text_decoder_runner_->load(); }
+
+  /**
+   * Check if the TextPrefiller has been successfully loaded.
+   * @return True if the resources are loaded, false otherwise.
+   */
+  bool inline is_loaded() const {
+    // Implementation to check if resources are loaded
+    return text_decoder_runner_->is_method_loaded();
+  }
+
+private:
+  /**
+   * Note: TextPrefiller does not own the TextDecoderRunner instance.
+   * The responsibility of managing the lifecycle of TextDecoderRunner
+   * lies with the outer class or entity (likely Runner) that creates
+   * and passes the TextDecoderRunner instance to TextPrefiller.
+   */
+  TextDecoderRunner *text_decoder_runner_;
+  bool use_kv_cache_;
+  bool enable_parallel_prefill_;
+  int64_t max_seq_len_;
+};
+
+} // namespace llm
+} // namespace extension
+} // namespace executorch
+
+namespace torch {
+namespace executor {
+// TODO(T197294990): Remove these deprecated aliases once all users have moved
+// to the new `::executorch` namespaces.
+using ::executorch::extension::llm::TextPrefiller;
+} // namespace executor
+} // namespace torch