Performance Optimization

import torch
from torch.ao.quantization.quantize_pt2e import convert_pt2e, prepare_pt2e
from torch.ao.quantization.quantizer.xnnpack_quantizer import (
    get_symmetric_quantization_config,
    XNNPACKQuantizer,
)
from executorch.exir import to_edge
from torch.export import export

# Load your model
model = YourModel()
model.eval()

# Prepare quantizer
quantizer = XNNPACKQuantizer()
quantization_config = get_symmetric_quantization_config(
    is_per_channel=True,  # Better accuracy than per-tensor
    is_dynamic=False,      # Static quantization for best performance
)
quantizer.set_global(quantization_config)

# Export model
example_inputs = (torch.randn(1, 3, 224, 224),)
aten_dialect = export(model, example_inputs)

# Apply quantization
prepared_model = prepare_pt2e(aten_dialect, quantizer)

# Calibrate with representative data (optional but recommended)
with torch.no_grad():
    for calibration_input in calibration_dataset:
        prepared_model(calibration_input)

# Convert to quantized model
quantized_model = convert_pt2e(prepared_model)

# Export to ExecuTorch
edge_program = to_edge(quantized_model)
executorch_program = edge_program.to_executorch()

with open("model_quantized.pte", "wb") as f:
    f.write(executorch_program.buffer)

quantization_config = get_symmetric_quantization_config(
    is_per_channel=True,
    is_dynamic=True,  # Quantize weights only, activations at runtime
)

# Per-channel (better accuracy, slightly slower)
config = get_symmetric_quantization_config(is_per_channel=True)

# Per-tensor (faster, lower accuracy)
config = get_symmetric_quantization_config(is_per_channel=False)

from executorch.examples.models.llama2 import LlamaRunner

# Export with SpinQuant
# This requires using the ExecuTorch Llama export scripts
# See: https://github.com/pytorch/executorch/tree/main/examples/models/llama2

python -m executorch.examples.models.llama2.export_llama \
  --checkpoint "path/to/checkpoint.pth" \
  --params "path/to/params.json" \
  --quantization_mode "spinquant" \
  -o "model_spinquant.pte"

python -m executorch.examples.models.llama2.export_llama \
  --checkpoint "path/to/checkpoint.pth" \
  --params "path/to/params.json" \
  --quantization_mode "qlora" \
  -o "model_qlora.pte"

from executorch.backends.xnnpack.partition.xnnpack_partitioner import XnnpackPartitioner

edge_program = to_edge(aten_dialect)
edge_program = edge_program.to_backend(XnnpackPartitioner())
executorch_program = edge_program.to_executorch()

from executorch.backends.apple.coreml.partition.coreml_partitioner import CoreMLPartitioner

edge_program = to_edge(aten_dialect)
edge_program = edge_program.to_backend(CoreMLPartitioner(
    skip_ops_for_coreml_delegation=[],  # Ops to run on CPU
    compute_precision="fp16",            # Use half precision
))
executorch_program = edge_program.to_executorch()

# For cross-platform consistency: XNNPACK
partitioner = XnnpackPartitioner()

# For iOS-specific optimization: Core ML
partitioner = CoreMLPartitioner()

# For maximum compatibility: No delegation (CPU fallback)
# Just use to_edge() without to_backend()

import { useLLM } from 'react-native-executorch';

const llm = useLLM({ model: LLAMA3_2_1B });

// Configure for performance
llm.configure({
  generationConfig: {
    temperature: 0.7,
    topP: 0.9,
    maxTokens: 512,      // Lower = faster responses
    sequenceLength: 1024, // Context window
  },
});

// Faster, more deterministic (lower temperature)
llm.configure({
  generationConfig: {
    temperature: 0.3,  // More focused, faster
    topP: 0.9,
  },
});

// More creative but slower
llm.configure({
  generationConfig: {
    temperature: 0.9,  // More random, requires more sampling
    topP: 0.95,
  },
});

import { 
  useLLM,
  SlidingWindowContextStrategy,
  MessageCountContextStrategy,
} from 'react-native-executorch';

// Limit context by token count
const contextStrategy = new SlidingWindowContextStrategy({
  maxTokens: 2048,  // Limit context size
});

// Or limit by message count
const contextStrategy = new MessageCountContextStrategy({
  maxMessages: 10,  // Keep last 10 messages only
});

llm.configure({
  chatConfig: {
    contextStrategy,
  },
});

import { useEffect } from 'react';
import { useLLM, LLAMA3_2_1B } from 'react-native-executorch';

function App() {
  const llm = useLLM({ model: LLAMA3_2_1B });

  useEffect(() => {
    // Model loads automatically on mount
    // Use preventLoad prop if you need manual control
  }, []);

  return /* Your app */;
}

import { ExpoResourceFetcher } from '@react-native-executorch/expo-resource-fetcher';

// Check if model is already downloaded
const models = await ExpoResourceFetcher.listDownloadedModels();
console.log('Cached models:', models);

// Pre-download models
await ExpoResourceFetcher.fetch(
  (progress) => console.log(`Download: ${progress * 100}%`),
  'https://your-cdn.com/model.pte'
);

import { useClassification } from 'react-native-executorch';

const classifier = useClassification({ model: EFFICIENTNET_V2_S });

// Process images sequentially
for (const image of images) {
  const result = await classifier.classify({ image });
  processResult(result);
}

const llm = useLLM({ model: LLAMA3_2_1B });

// Start generation
const promise = llm.generate(messages);

// User cancels
llm.interrupt();

const llm = useLLM({ model: LLAMA3_2_1B });

const startTime = Date.now();
await llm.generate(messages);
const endTime = Date.now();

const tokenCount = llm.getGeneratedTokenCount();
const tokensPerSecond = tokenCount / ((endTime - startTime) / 1000);

console.log(`Speed: ${tokensPerSecond.toFixed(2)} tokens/sec`);

const llm = useLLM({ model: LLAMA3_2_1B });

useEffect(() => {
  console.log(`Download: ${llm.downloadProgress * 100}%`);
}, [llm.downloadProgress]);

import { Platform } from 'react-native';

if (Platform.OS === 'ios') {
  // Use Core ML optimized models on iOS
  // Ensure models were exported with CoreMLPartitioner
}

# Edit AVD in Android Studio
# Increase RAM to 4GB+ for LLM testing