Guía de inferencia de LLM

⚠️ Importante: Actualización de la API de LLM Inference

Las implementaciones para Android y iOS de la API de LLM Inference ahora están obsoletas. La Web NO está obsoleta

---

Migra tus proyectos para dispositivos móviles a LiteRT-LM para garantizar la compatibilidad y el rendimiento continuos.

La API de LLM Inference te permite ejecutar modelos grandes de lenguaje (LLM) por completo en el dispositivo, 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 para varios modelos grandes de lenguaje de texto a texto, por lo que puedes aplicar los modelos de IA generativa más recientes en el dispositivo a tus apps y productos.

Pruébaloarrow_forward

La tarea proporciona compatibilidad integrada para una variedad de LLM. Los modelos alojados en la página de la comunidad de LiteRT están disponibles en un formato compatible con MediaPipe y no requieren pasos adicionales de conversión o compilación.

Puedes usar LiteRT Torch para exportar modelos de PyTorch a modelos de LiteRT de varias firmas (tflite), que se agrupan con parámetros de tokenizador para crear paquetes de tareas. Los modelos convertidos con LiteRT Torch son compatibles con la API de LLM Inference y se pueden ejecutar en el backend de CPU, lo que los hace adecuados para aplicaciones para Android y iOS.

Comenzar

Para comenzar a usar esta tarea, sigue una de estas guías de implementación para tu plataforma de destino. Estas guías específicas de la plataforma te guían a través de una implementación básica de esta tarea, con ejemplos de código que usan un modelo disponible y las opciones de configuración recomendadas:

• Web:

  • Guía
  • Ejemplo de código

• Android:

  • Guía
  • Ejemplo de código

• iOS

  • Guía
  • Ejemplo de código

Detalles de la tarea

En esta sección, se describen las capacidades, las entradas, las salidas y las opciones de configuración de esta tarea.

Funciones

La API de LLM Inference contiene las siguientes funciones clave:

1. Generación de texto a texto : Genera texto en función de una instrucción de texto de entrada.
2. Selección de LLM : Aplica varios modelos para adaptar la app a tus casos de uso específicos. También puedes volver a entrenar y aplicar ponderaciones personalizadas al modelo.
3. Compatibilidad con LoRA : Extiende y personaliza la capacidad de LLM con el modelo LoRA entrenando en todo tu conjunto de datos o tomando modelos LoRA compilados previamente preparados de la comunidad de código abierto (no compatible con modelos convertidos con la API generativa de LiteRT Torch).

Opciones de configuración

Esta tarea tiene las siguientes opciones de configuración:

Modelos

La API de LLM Inference admite muchos modelos grandes de lenguaje de texto a texto, incluida la compatibilidad integrada para varios modelos optimizados para ejecutarse en navegadores y dispositivos móviles. Estos modelos livianos se pueden usar para ejecutar inferencias por completo en el dispositivo.

Antes de inicializar la API de LLM Inference, descarga un modelo y almacena el archivo en el directorio de tu proyecto. Puedes usar un modelo previamente convertido del repositorio de HuggingFace de la comunidad de LiteRT o convertir un modelo a un formato compatible con MediaPipe con el conversor generativo de AI Edge Torch.

Si aún no tienes un LLM para usar con la API de LLM Inference, comienza con uno de los siguientes modelos.

Gemma-3n

Gemma-3n E2B y E4B son los modelos más recientes de la familia Gemma de modelos abiertos livianos y de última generación creados a partir de la misma investigación y tecnología que se utilizaron para crear los Gemini. Los modelos de Gemma 3n están diseñados para una ejecución eficiente en dispositivos con pocos recursos. Son capaces de manejar entradas multimodales, texto, imágenes y audio, y generar salidas de texto.

Los modelos de Gemma 3n usan tecnología de activación de parámetros selectiva para reducir los requisitos de recursos. Esta técnica permite que los modelos operen con un tamaño efectivo de 2B y 4B parámetros, que es inferior a la cantidad total de parámetros que contienen.

Descargar Gemma-3n E2B

Descargar Gemma-3n E4B

Los modelos Gemma-3n E2B y E4B de HuggingFace están disponibles en formato .litertlm y están listos para usarse con la API de LLM Inference para Android y la Web.

Gemma-3 1B

Gemma-3 1B es el modelo más liviano de la familia Gemma de modelos abiertos livianos y de última generación creados a partir de la misma investigación y tecnología que se utilizaron para crear los modelos de Gemini. El modelo contiene 1B parámetros y ponderaciones abiertas.

Descargar Gemma-3 1B

El modelo Gemma-3 1B de HuggingFace está disponible en formato .task/.litertlm y está listo para usarse con la API de LLM Inference para aplicaciones para Android y la Web.

Cuando ejecutes Gemma-3 1B con la API de LLM Inference, configura las siguientes opciones según corresponda:

• preferredBackend: Usa esta opción para elegir entre un backend CPU o GPU. Esta opción solo está disponible para Android.
• supportedLoraRanks: La API de LLM Inference no se puede configurar para admitir la adaptación de clasificación baja (LoRA) con el modelo Gemma-3 1B. No uses las opciones supportedLoraRanks ni loraRanks.
• maxTokens: El valor de maxTokens debe coincidir con el tamaño del contexto integrado en el modelo. Esto también se puede denominar caché de clave-valor (KV) o longitud del contexto.
• numResponses: Siempre debe ser 1. Esta opción solo está disponible para la Web.

Cuando se ejecuta Gemma-3 1B en aplicaciones web, la inicialización puede causar un bloqueo prolongado en el subproceso actual. Si es posible, siempre ejecuta el modelo desde un subproceso de trabajador.

Gemma-2 2B

Gemma-2 2B es una variante de 2B de Gemma-2 y funciona en todas las plataformas.

Descargar Gemma-2 2B

El modelo contiene 2B parámetros y ponderaciones abiertas. Gemma-2 2B es conocido por sus habilidades de razonamiento de última generación para modelos de su clase.

Conversión de modelos de PyTorch

Los modelos generativos de PyTorch se pueden convertir a un formato compatible con MediaPipe con la API generativa de LiteRT Torch. Puedes usar la API para convertir modelos de PyTorch en modelos de LiteRT de varias firmas (TensorFlow Lite). Para obtener más detalles sobre la asignación y la exportación de modelos, visita la página de GitHub de LiteRT Torch.

La conversión de un modelo de PyTorch con la API generativa de LiteRT Torch implica los siguientes pasos:

1. Descarga los puntos de control del modelo de PyTorch.
2. Usa la API generativa de LiteRT Torch para crear, convertir y cuantizar el modelo a un formato de archivo compatible con MediaPipe (.tflite).
3. Crea un paquete de tareas (.task/.litertlm) a partir del archivo tflite y el tokenizador del modelo.

El conversor generativo de Torch solo realiza conversiones para CPU y requiere una máquina Linux con al menos 64 GB de RAM.

Para crear un paquete de tareas, usa la secuencia de comandos de agrupación para crear un paquete de tareas. El proceso de agrupación empaqueta el modelo asignado con metadatos adicionales (p.ej., parámetros de tokenizador) necesarios para ejecutar la inferencia de extremo a extremo.

El proceso de agrupación de modelos requiere el paquete MediaPipe PyPI. La secuencia de comandos de conversión está disponible en todos los paquetes de MediaPipe después de 0.10.14.

Instala e importa las dependencias con lo siguiente:

$ python3 -m pip install mediapipe

Usa la biblioteca genai.bundler para agrupar el modelo:

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

config = bundler.BundleConfig(
    tflite_model=TFLITE_MODEL,
    tokenizer_model=TOKENIZER_MODEL,
    start_token=START_TOKEN,
    stop_tokens=STOP_TOKENS,
    output_filename=OUTPUT_FILENAME,
    enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)

Personalización de LoRA

La compatibilidad con LoRA de la API de LLM Inference funciona para todas las variantes de Gemma y los modelos Phi-2 para el backend de GPU, con ponderaciones de LoRA aplicables solo a las capas de atención. Esta implementación inicial sirve como una API experimental para desarrollos futuros con planes para admitir más modelos y varios tipos de capas en las próximas actualizaciones.

Prepara modelos LoRA

Sigue las instrucciones de HuggingFace para entrenar un modelo LoRA ajustado en tu propio conjunto de datos con tipos de modelos compatibles, Gemma o Phi-2. Los modelos Gemma-2 2B, Gemma 2B y Phi-2 están disponibles en HuggingFace en formato safetensors. Dado que la API de LLM Inference solo admite LoRA en capas de atención, solo especifica las capas de atención mientras creas LoraConfig de la siguiente manera:

# 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"],
)

Para las pruebas, hay modelos LoRA ajustados de acceso público que se ajustan a la API de LLM Inference disponible en HuggingFace. Por ejemplo, monsterapi/gemma-2b-lora-maths-orca-200k para Gemma-2B y lole25/phi-2-sft-ultrachat-lora para Phi-2.

Después de entrenar en el conjunto de datos preparado y guardar el modelo, obtendrás un archivo adapter_model.safetensors que contiene las ponderaciones del modelo LoRA ajustado. El archivo safetensors es el punto de control de LoRA que se usa en la conversión del modelo.

Como siguiente paso, debes convertir las ponderaciones del modelo en un Flatbuffer de TensorFlow Lite con el paquete de Python de MediaPipe. ConversionConfig debe especificar las opciones del modelo base, así como las opciones adicionales de LoRA. Ten en cuenta que como la API solo admite la inferencia de LoRA con GPU, el backend debe establecerse en 'gpu'.

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_TFLITE_FILE,
)

converter.convert_checkpoint(config)

El conversor generará dos archivos flatbuffer de TFLite, uno para el modelo base y el otro para el modelo LoRA.

Inferencia de modelos LoRA

Se actualizó la API de LLM Inference para la Web, Android y iOS para admitir la inferencia de modelos LoRA.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('<path to base model>')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath('<path to LoRA model>')
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

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