On-device inference mobile: ExecuTorch, MediaPipe, Core ML

# ExecuTorch — pipeline de exportação Llama 3.2 1B para iOS
import torch
from executorch.examples.models.llama2 import Llama2Model
from executorch.exir import to_edge
from executorch.backends.apple.coreml.partition.coreml_partitioner import CoreMLPartitioner

# 1. Carrega modelo PyTorch
model = Llama2Model("Llama-3.2-1B-Instruct", checkpoint_path="./consolidated.pth")
model.eval()

# 2. Quantização INT4 (groupwise) via PT2E
from torch.ao.quantization.quantizer.embedding_quantizer import EmbeddingQuantizer
from torch.ao.quantization.quantizer.coreml_quantizer import CoreMLQuantizer

quantizer = CoreMLQuantizer(bits=4, group_size=64)
m = torch._export.capture_pre_autograd_graph(model, example_inputs)
m = prepare_pt2e(m, quantizer)
# calibração
for batch in calib_loader: m(batch)
m = convert_pt2e(m)

# 3. Exporta para Edge IR
edge = to_edge(torch.export(m, example_inputs))

# 4. Delegate para Core ML (otimiza para ANE)
edge = edge.to_backend(CoreMLPartitioner())

# 5. Salva .pte
prog = edge.to_executorch()
with open("llama-3.2-1b-coreml-int4.pte", "wb") as f:
    f.write(prog.buffer)

// Runtime em iOS (Swift) — usando ExecuTorch
import ExecuTorchLLM

let modelPath = Bundle.main.path(forResource: "llama-3.2-1b-coreml-int4", ofType: "pte")!
let tokenizerPath = Bundle.main.path(forResource: "tokenizer", ofType: "json")!

let runner = try LLMRunner(modelPath: modelPath, tokenizerPath: tokenizerPath)

let prompt = "Resuma este email em 2 frases: ..."
try await runner.generate(prompt: prompt, maxTokens: 200) { token in
    DispatchQueue.main.async { self.streamingText += token }
}

// Android Kotlin — MediaPipe LLM Inference
import com.google.mediapipe.tasks.genai.llminference.LlmInference

class GemmaService(context: Context) {
    private val llm: LlmInference

    init {
        val options = LlmInference.LlmInferenceOptions.builder()
            .setModelPath("/data/local/tmp/gemma-2b-it-gpu-int4.task")
            .setMaxTokens(2048)
            .setMaxTopK(40)
            .setTemperature(0.7f)
            .setPreferredBackend(LlmInference.Backend.GPU)  // ou CPU
            .build()
        llm = LlmInference.createFromOptions(context, options)
    }

    suspend fun generate(prompt: String): String = withContext(Dispatchers.IO) {
        llm.generateResponse(prompt)
    }
}

// Web — MediaPipe LLM Inference no browser via WebGPU
import { FilesetResolver, LlmInference } from "@mediapipe/tasks-genai";

const genai = await FilesetResolver.forGenAiTasks(
  "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai/wasm",
);

const llm = await LlmInference.createFromOptions(genai, {
  baseOptions: { modelAssetPath: "/models/gemma-2b-it-gpu-int4.bin" },
  maxTokens: 1024,
  topK: 40,
  temperature: 0.7,
  randomSeed: 101,
});

const response = await llm.generateResponse("Explique RAG em 2 frases.");

// Apple Foundation Models — iOS 26+
import FoundationModels

// 1. Verifica disponibilidade (iPhone 15 Pro+, iPad M-series, todos Mac)
guard SystemLanguageModel.default.availability == .available else { return }

// 2. Sessão com guided generation (Swift macros para schema-aware output)
@Generable struct EmailSummary {
    @Guide(description: "Resumo em 2 frases, PT-BR")
    let summary: String

    @Guide(description: "Lista de action items")
    let actions: [String]

    let urgency: Urgency

    enum Urgency: String, Generable {
        case low, medium, high
    }
}

let session = LanguageModelSession(instructions: """
Você resume emails profissionais em português.
""")

let result = try await session.respond(
    to: emailContent,
    generating: EmailSummary.self,
)

print(result.content.summary)        // typed!
print(result.content.actions)
print(result.content.urgency)