Guía de inferencia de LLM

La API de LLM Inference te permite ejecutar modelos de lenguaje grandes (LLM) completamente en el dispositivo, lo que puedes usar para realizar una amplia variedad de tareas, como generar texto, recuperar información en formato de lenguaje natural y resumir documentos. La tarea proporciona compatibilidad integrada con varios modelos grandes de lenguaje de texto a texto, por lo que puedes aplicar los modelos de IA generativa en el dispositivo más recientes 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 AI Edge Torch para exportar modelos de PyTorch a modelos de LiteRT (tflite) de varias firmas, que se incluyen con parámetros de tokenizador para crear paquetes de tareas. Los modelos convertidos con AI Edge Torch son compatibles con la API de LLM Inference y se pueden ejecutar en el backend de la 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. En estas guías específicas para cada plataforma, se explica 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 a partir 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 el modelo y aplicarle pesos personalizados.
3. Compatibilidad con LoRA: Extiende y personaliza la capacidad del LLM con el modelo LoRA entrenándolo en todo tu conjunto de datos o tomando modelos LoRA prediseñados preparados de la comunidad de código abierto (no es compatible con los modelos convertidos con la API de AI Edge Torch Generative).

Opciones de configuración

Esta tarea tiene las siguientes opciones de configuración:

Modelos

La API de LLM Inference admite muchos modelos de lenguaje grande de texto a texto, incluido el soporte integrado para varios modelos optimizados para ejecutarse en navegadores y dispositivos móviles. Estos modelos livianos se pueden usar para ejecutar inferencias completamente 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 LiteRT Community de Hugging Face o convertir un modelo a un formato compatible con MediaPipe con el convertidor generativo de Torch de AI Edge.

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, ligeros y de vanguardia creados a partir de la misma investigación y tecnología que se usaron para crear los modelos de Gemini. Los modelos de Gemma 3n están diseñados para ejecutarse de manera eficiente en dispositivos con pocos recursos. Son capaces de recibir entradas multimodales, manejar entradas de texto, imagen y audio, y generar salidas de texto.

Los modelos de Gemma 3n usan tecnología de activación selectiva de parámetros para reducir los requisitos de recursos. Esta técnica permite que los modelos operen con un tamaño efectivo de 2,000 y 4,000 millones de parámetros, lo 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 ligero de la familia Gemma de modelos abiertos, ligeros y de vanguardia creados a partir de la misma investigación y tecnología que se utilizaron para crear los modelos de Gemini. El modelo contiene 1,000 millones de parámetros y ponderaciones abiertas.

Descargar Gemma-3 1B

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

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 de 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 bajo rango (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. También se puede hacer referencia a esto como la caché de clave-valor (KV) o la 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 trabajo.

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 2,000 millones de parámetros y ponderaciones abiertas. Gemma-2 2B es conocido por sus habilidades de razonamiento de vanguardia para los 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 de AI Edge Torch Generative. Puedes usar la API para convertir modelos de PyTorch en modelos de LiteRT (TensorFlow Lite) con varias firmas. Para obtener más detalles sobre la asignación y exportación de modelos, visita la página de GitHub de AI Edge Torch.

La conversión de un modelo de PyTorch con la API de AI Edge Torch Generative implica los siguientes pasos:

1. Descarga los puntos de control del modelo de PyTorch.
2. Usa la API de AI Edge Torch Generative para crear, convertir y cuantificar el modelo en 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 convertidor generativo de Torch solo realiza conversiones para la CPU y requiere una máquina Linux con al menos 64 GB de RAM.

Para crear un paquete de tareas, usa el script de empaquetado para crear un paquete de tareas. El proceso de empaquetado incluye el modelo asignado con metadatos adicionales (p.ej., Parámetros del tokenizador) necesarios para ejecutar la inferencia de extremo a extremo.

El proceso de agrupamiento de modelos requiere el paquete de MediaPipe de 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 el siguiente comando:

$ python3 -m pip install mediapipe

Usa la biblioteca genai.bundler para empaquetar 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 de Phi-2 para el backend de GPU, con pesos de LoRA aplicables solo a las capas de atención. Esta implementación inicial funciona como una API experimental para desarrollos futuros, con planes de admitir más modelos y varios tipos de capas en las próximas actualizaciones.

Prepara modelos LoRA

Sigue las instrucciones en HuggingFace para entrenar un modelo LoRA ajustado en tu propio conjunto de datos con tipos de modelos compatibles, como Gemma o Phi-2. Los modelos Gemma-2 2B, Gemma 2B y Phi-2 están disponibles en Hugging Face en formato safetensors. Dado que la API de LLM Inference solo admite LoRA en las capas de atención, solo especifica las capas de atención cuando crees el 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 disponibles públicamente 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 el modelo con el conjunto de datos preparado y guardarlo, obtendrás un archivo adapter_model.safetensors que contiene los pesos 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 los pesos del modelo en un FlatBuffer de TensorFlow Lite con el paquete de Python de MediaPipe. El ConversionConfig debe especificar las opciones del modelo base y 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 otro para el modelo LoRA.

Inferencia de modelos LoRA

Se actualizaron las APIs de LLM Inference para 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 del LLM con LoRA, usa los mismos métodos generateResponse() o generateResponseAsync() que el modelo base.