Guía de inferencia de LLM para iOS

La API de LLM Inference te permite ejecutar modelos grandes de lenguaje (LLM) completamente en el dispositivo para aplicaciones para iOS, que puedes usar para realizar una amplia variedad de tareas, como generar texto, recuperar información en forma de lenguaje natural y resumir documentos. La tarea proporciona compatibilidad integrada con varios modelos grandes de lenguaje de texto a texto, de modo que puedas aplicar los modelos de IA generativa más recientes en el dispositivo a tus apps para iOS.

Para agregar rápidamente la API de LLM Inference a tu aplicación para iOS, sigue la Guía de inicio rápido. Para ver un ejemplo básico de una aplicación para iOS que ejecuta la API de LLM Inference, consulta la aplicación de ejemplo. Para obtener una explicación más detallada del funcionamiento de la API de LLM Inference, consulta las secciones opciones de configuración, conversión de modelos y ajuste de LoRA.

Puedes ver esta tarea en acción con la demo de MediaPipe Studio. Para obtener más información sobre las funciones, los modelos y las opciones de configuración de esta tarea, consulta la descripción general.

Guía de inicio rápido

Sigue estos pasos para agregar la API de LLM Inference a tu aplicación para iOS. La API de LLM Inference usa la biblioteca MediaPipeTasksGenai, que se debe instalar con CocoaPods. La biblioteca es compatible con apps de Swift y Objective-C, y no requiere ninguna configuración adicional específica del lenguaje.

Para obtener instrucciones para instalar CocoaPods en macOS, consulta la guía de instalación de CocoaPods. Para obtener instrucciones sobre cómo crear un Podfile con los pods necesarios para tu app, consulta Cómo usar CocoaPods.

Cómo agregar dependencias

Agrega el pod MediaPipeTasksGenai en Podfile con el siguiente código:

target 'MyLlmInferenceApp' do
  use_frameworks!
  pod 'MediaPipeTasksGenAI'
  pod 'MediaPipeTasksGenAIC'
end

Si tu app incluye destinos de pruebas de unidades, consulta la Guía de configuración para iOS para obtener información adicional sobre cómo configurar tu Podfile.

Descarga un modelo

Descarga Gemma-2 2B en un formato cuantificado de 8 bits desde Modelos de Kaggle. Para obtener más información sobre los modelos disponibles, consulta la documentación de los modelos.

Agrega el modelo al directorio de tu proyecto con Xcode. Si deseas obtener instrucciones para añadir archivos a tu proyecto de Xcode, consulta Cómo administrar archivos y carpetas en tu proyecto de Xcode.

Inicializa la tarea

Inicializa la tarea con las opciones de configuración básicas:

import MediaPipeTasksGenai

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "bin")

let options = LlmInferenceOptions()
options.baseOptions.modelPath = modelPath
options.maxTokens = 1000
options.topk = 40
options.temperature = 0.8
options.randomSeed = 101

let llmInference = try LlmInference(options: options)

Ejecuta la tarea

Usa el método generateResponse(inputText:) para generar una respuesta de texto. Esto genera una sola respuesta generada.

let result = try LlmInference.generateResponse(inputText: inputPrompt)

Para transmitir la respuesta, usa el método generateResponseAsync(inputText:).

let resultStream =  LlmInference.generateResponseAsync(inputText: inputPrompt)

do {
  for try await partialResult in resultStream {
    print("\(partialResult)")
  }
  print("Done")
}
catch {
  print("Response error: '\(error)")
}

Aplicación de ejemplo

La aplicación de ejemplo es un ejemplo de una app de generación de texto básica para iOS que usa la API de inferencia de LLM. Puedes usar la app como punto de partida para tu propia app para iOS o consultarla cuando modifiques una app existente. El código de ejemplo se aloja en GitHub.

Clona el repositorio de git con el siguiente comando:

git clone https://github.com/google-ai-edge/mediapipe-samples

Después de crear una versión local del código de ejemplo, puedes importar el proyecto a iOS Studio y ejecutar la app. Para obtener más información, consulta la Guía de configuración para iOS.

Opciones de configuración

Usa las siguientes opciones de configuración para configurar una app para iOS:

Conversión de modelos

La API de inferencia de LLM es compatible con los siguientes tipos de modelos, algunos de los cuales requieren conversión de modelos. Usa la tabla para identificar el método de pasos necesarios para tu modelo.

Para obtener información sobre cómo convertir otros modelos, consulta la sección Conversión de modelos.

Personalización de LoRA

La API de Inference de LLM admite el ajuste de LoRA (adaptación de clasificación baja) con la biblioteca PEFT (ajuste fino eficiente en parámetros). El ajuste de LoRA personaliza el comportamiento de los LLM a través de un proceso de entrenamiento rentable, lo que crea un pequeño conjunto de pesos entrenables basados en datos de entrenamiento nuevos en lugar de volver a entrenar todo el modelo.

La API de inferencia de LLM admite la adición de ponderaciones de LoRA a las capas de atención de los modelos Gemma-2 2B, Gemma 2B y Phi-2. Descarga el modelo en formato safetensors.

El modelo de base debe estar en formato safetensors para crear pesos de LoRA. Después del entrenamiento de LoRA, puedes convertir los modelos al formato FlatBuffers para ejecutarlos en MediaPipe.

Prepara los pesos de LoRA

Usa la guía de métodos LoRA de PEFT para entrenar un modelo LoRA ajustado en tu propio conjunto de datos.

La API de LLM Inference solo admite LoRA en las capas de atención, por lo que solo debes especificar las capas de atención en LoraConfig:

# For Gemma
from peft import LoraConfig
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)

# For Phi-2
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "dense"],
)

Después de entrenar el conjunto de datos preparado y guardar el modelo, los pesos del modelo LoRA ajustados están disponibles en adapter_model.safetensors. El archivo safetensors es el punto de control de LoRA que se usa durante la conversión de modelos.

Conversión de modelos

Usa el paquete de Python de MediaPipe para convertir las ponderaciones del modelo en el formato Flatbuffer. ConversionConfig especifica las opciones del modelo base junto con las opciones adicionales de LoRA.

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_FILE,
)

converter.convert_checkpoint(config)

El convertidor producirá dos archivos Flatbuffer, uno para el modelo base y otro para el modelo LoRA.

Inferencia de modelos de LoRA

iOS admite LoRa estático durante la inicialización. Para cargar un modelo de LoRA, especifica la ruta de acceso del modelo de LoRA y el LLM base.

import MediaPipeTasksGenai

let modelPath = Bundle.main.path(forResource: "model",
                                      ofType: "bin")
let loraPath= Bundle.main.path(forResource: "lora_model",
                                      ofType: "bin")
let options = LlmInferenceOptions()
options.modelPath = modelPath
options.maxTokens = 1000
options.topk = 40
options.temperature = 0.8
options.randomSeed = 101
options.loraPath = loraPath

let llmInference = try LlmInference(options: options)

Para ejecutar la inferencia de LLM con LoRA, usa los mismos métodos generateResponse() o generateResponseAsync() que el modelo base.