Guía de inferencia de LLM

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 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 y productos.

Pruébala.arrow_forward

La tarea admite las siguientes variantes de Gemma: Gemma-2 2B, Gemma 2B y Gemma 7B. Gemma es una familia de modelos abiertos, livianos y de vanguardia creados a partir de la misma investigación y tecnología que se utilizaron para crear los modelos de Gemini. También admite los siguientes modelos externos: Phi-2, Falcon-RW-1B y StableLM-3B.

Además de los modelos compatibles, puedes usar AI Edge Torch de Google para exportar modelos de PyTorch a modelos LiteRT (tflite) de varias firmas, que se agrupan con parámetros de tokenizador para crear paquetes de tareas compatibles con la API de inferencia de LLM. Los modelos convertidos con AI Edge Torch solo se pueden ejecutar en el backend de la CPU y, por lo tanto, se limitan a 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 de la 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 y aplicar pesos personalizados al modelo.
3. Compatibilidad con LoRA: Extiende y personaliza la capacidad de LLM con el modelo LoRA entrenando todo tu conjunto de datos o tomando modelos LoRA precompilados preparados de la comunidad de código abierto (no es compatible con los modelos convertidos con la API generativa de AI Edge 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 con varios modelos que están optimizados para ejecutarse en navegadores y dispositivos móviles. Estos modelos ligeros 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 dentro del directorio de tu proyecto. Puedes usar un modelo previamente convertido o convertir un modelo a un formato compatible con MediaPipe.

La API de inferencia de LLM es compatible con dos tipos de categorías 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.

Almacenamos los archivos .bin convertidos para Gemma 2B, Gemma 7B y Gemma-2 2B en Kaggle. Estos modelos se pueden implementar directamente con nuestra API de inferencia de LLM. Para obtener información sobre cómo convertir otros modelos, consulta la sección Conversión de modelos.

Gemma-2 2B

Gemma-2 2B es el modelo más reciente de la familia de modelos abiertos, ligeros y de vanguardia de Gemma, compilados a partir de la misma investigación y tecnología que se usaron para crear los modelos de Gemini. El modelo contiene 2,000 millones de parámetros y ponderaciones abiertas. Gemma-2 2B se destaca por sus habilidades de razonamiento de vanguardia para los modelos de su clase.

Descarga Gemma-2 2B

Los modelos Gemma-2 2B están disponibles en las siguientes variantes:

• gemma2-2b-it-cpu-int8: Gemma-2 2B modelo de 8 bits con compatibilidad con CPU.
• gemma2-2b-it-gpu-int8: Gemma-2 2B modelo de 8 bits con compatibilidad con GPU.

También puedes ajustar el modelo y agregar pesos nuevos antes de agregarlo a la app. Para obtener más información sobre cómo ajustar y personalizar Gemma, consulta Cómo ajustar Gemma. Después de descargar Gemma-2B de Kaggle Models, el modelo ya está en el formato adecuado para usarlo con MediaPipe Tasks.

Gemma 2B

Gemma 2B forma parte de una familia 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 2,000 millones de parámetros y ponderaciones abiertas. Este modelo es adecuado para una variedad de tareas de generación de texto, como la respuesta a preguntas, el resumen y el razonamiento.

Descarga Gemma 2B

Los modelos Gemma 2B están disponibles en las siguientes variantes:

• gemma-2b-it-cpu-int4: Es el modelo de 4 bits Gemma 2B con compatibilidad con CPU.
• gemma-2b-it-cpu-int8: Gemma 2B es un modelo de 8 bits con compatibilidad con CPU.
• gemma-2b-it-gpu-int4: Gemma 2B es un modelo de 4 bits con compatibilidad con GPU.
• gemma-2b-it-gpu-int8: Gemma 2B es un modelo de 8 bits con compatibilidad con GPU.

También puedes ajustar el modelo y agregar pesos nuevos antes de agregarlo a la app. Para obtener más información sobre cómo ajustar y personalizar Gemma, consulta Cómo ajustar Gemma. Después de descargar Gemma 2B de Kaggle Models, el modelo ya está en el formato adecuado para usarlo con MediaPipe Tasks.

Gemma 7B

Gemma 7B es un modelo de Gemma más grande con 7,000 millones de parámetros y pesos abiertos. El modelo es más potente para una variedad de tareas de generación de texto, como la respuesta a preguntas, el resumen y el razonamiento. Gemma 7B solo es compatible con la Web.

Descarga Gemma 7B

El modelo Gemma 7B tiene una variante:

• gemma-1.1-7b-it-gpu-int8: Es el modelo de 8 bits Gemma 7B con compatibilidad con GPU.

Después de descargar Gemma 7B de Kaggle Models, el modelo ya está en el formato adecuado para usarlo con MediaPipe.

Falcon 1B

Falcon-1B es un modelo causal de solo decodificador de 1,000 millones de parámetros que se entrenó en 350,000 millones de tokens de RefinedWeb.

Descarga Falcon 1B

La API de LLM Inference requiere que se descarguen y almacenen los siguientes archivos de forma local:

• tokenizer.json
• tokenizer_config.json
• pytorch_model.bin

Después de descargar los archivos del modelo de Falcon, el modelo está listo para convertirse al formato MediaPipe con una secuencia de comandos de conversión. Sigue los pasos que se indican en la sección Secuencia de comandos de conversión para modelos compatibles.

StableLM 3B

StableLM-3B es un modelo de lenguaje solo con decodificador de 3,000 millones de parámetros que se entrenó previamente en 1 billón de tokens de diversos conjuntos de datos de código y en inglés durante 4 épocas.

Descarga StableLM 3B

La API de LLM Inference requiere que se descarguen y almacenen los siguientes archivos de forma local:

• tokenizer.json
• tokenizer_config.json
• model.safetensors

Después de descargar los archivos del modelo de StableLM, el modelo está listo para convertirse al formato MediaPipe con una secuencia de comandos de conversión. Sigue los pasos que se indican en la sección Secuencia de comandos de conversión para modelos compatibles.

Phi-2

Phi-2 es un modelo Transformer de 2,700 millones de parámetros. Se entrenó con varios textos sintéticos de NLP y sitios web filtrados. El modelo es más adecuado para las instrucciones que usan el formato de pregunta y respuesta, chat y código.

Descarga Phi-2

La API de LLM Inference requiere que se descarguen y almacenen los siguientes archivos de forma local:

• tokenizer.json
• tokenizer_config.json
• model-00001-of-00002.safetensors
• model-00002-of-00002.safetensors

Después de descargar los archivos del modelo Phi-2, el modelo está listo para convertirse al formato MediaPipe con una secuencia de comandos de conversión. Sigue los pasos que se indican en la sección Secuencia de comandos de conversión para modelos compatibles.

Modelos generativos 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 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.

Si deseas usar la API de Torch Generative de AI Edge para convertir un modelo de PyTorch, sigue los pasos que se indican en la sección Convertidor generativo de Torch para modelos de PyTorch.

Conversión de modelos

La API de MediaPipe LLM Inference te permite ejecutar una amplia variedad de modelos de lenguaje grande en el dispositivo. Esto incluye los modelos que se convirtieron previamente a un formato compatible con MediaPipe, así como otros modelos que se pueden convertir con una secuencia de comandos de conversión o la biblioteca de AI Edge Torch.

La API de LLM Inference acepta modelos en los formatos de archivo .bin y .task. Los modelos previamente convertidos y los convertidos con la secuencia de comandos de conversión serán archivos .bin, mientras que los modelos convertidos con la biblioteca de AI Edge Torch serán archivos .task. No alteres manualmente los formatos de archivo de tus modelos convertidos.

La API de inferencia de LLM contiene tres rutas de conversión de modelos:

• Modelos previamente convertidos (Gemma 2B, Gemma 7B y Gemma-2 2B): No se requiere conversión.
• Modelos compatibles (Phi-2, StableLM, Falcon): Secuencia de comandos de conversión de MediaPipe.
• Otros modelos de PyTorch (todos los modelos de LLM de PyTorch): API generativa de AI Edge Torch.

Modelos convertidos previamente

Los modelos Gemma-2 2B, Gemma 2B y Gemma 7B están disponibles como modelos previamente convertidos en el formato MediaPipe. Estos modelos no requieren ningún paso de conversión adicional por parte del usuario y se pueden ejecutar tal como están con la API de inferencia de LLM.

Puedes descargar el modelo Gemma-2 2B desde los modelos de Kaggle:

• gemma2-2b-it-cpu-int8: Gemma-2 2B modelo de 8 bits con compatibilidad con CPU.
• gemma2-2b-it-gpu-int8: Gemma-2 2B modelo de 8 bits con compatibilidad con GPU.

Puedes descargar variantes de Gemma 2B desde los modelos de Kaggle:

• gemma-2b-it-cpu-int4: Es el modelo de 4 bits Gemma 2B con compatibilidad con CPU.
• gemma-2b-it-cpu-int8: Gemma 2B es un modelo de 8 bits con compatibilidad con CPU.
• gemma-2b-it-gpu-int4: Gemma 2B es un modelo de 4 bits con compatibilidad con GPU.
• gemma-2b-it-gpu-int8: Gemma 2B es un modelo de 8 bits con compatibilidad con GPU.

Puedes descargar el modelo Gemma 7B desde Kaggle Models:

• gemma-1.1-7b-it-gpu-int8: Es el modelo de 8 bits Gemma 7B con compatibilidad con GPU.

Para obtener más información sobre los modelos de Gemma, consulta la documentación sobre Gemma-2 2B, Gemma 2B y Gemma 7B.

Secuencia de comandos de conversión para modelos compatibles

El paquete MediaPipe ofrece una secuencia de comandos de conversión para convertir los siguientes modelos externos en un formato compatible con MediaPipe:

• Falcon 1B
• StableLM 3B
• Phi-2

Para obtener más información sobre los modelos externos admitidos, consulta la documentación sobre Falcon 1B, StableLM 3B y Phi-2.

El proceso de conversió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.11.

Instala y, luego, importa las dependencias con lo siguiente:

$ python3 -m pip install mediapipe

Usa la biblioteca genai.converter para convertir el modelo:

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

config = converter.ConversionConfig(
  input_ckpt=INPUT_CKPT,
  ckpt_format=CKPT_FORMAT,
  model_type=MODEL_TYPE,
  backend=BACKEND,
  output_dir=OUTPUT_DIR,
  combine_file_only=False,
  vocab_model_file=VOCAB_MODEL_FILE,
  output_tflite_file=OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

Para convertir el modelo LoRA, 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 se debe establecer 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 convertidor generará dos archivos FlatBuffer de TFLite, uno para el modelo base y el otro para el modelo LoRA.

Torch Generative Converter para 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 crear, convertir y cuantificar LLM de PyTorch para usar con la API de LLM Inference. El convertidor generativo de Torch solo realiza conversiones para CPU y requiere una máquina Linux con al menos 64 GB de RAM.

La conversión de un modelo de PyTorch con la API de AI Edge Torch Generative implica lo siguiente:

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

Para crear un paquete de tareas, usa la secuencia de comandos de empaquetado para crear un paquete de tareas. El proceso de agrupación empaqueta el modelo asignado con metadatos adicionales (p.ej., Parámetros del analizador) 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 y, luego, importa las dependencias con lo siguiente:

$ 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 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 futuros desarrollos con planes para admitir más modelos y varios tipos de capas en las próximas actualizaciones.

Prepara modelos de LoRA

Sigue las instrucciones en HuggingFace para entrenar un modelo LoRA ajustado en tu propio conjunto de datos con los tipos de modelos compatibles, Gemma o Phi-2. Los modelos Gemma-2 2B, Gemma 2B y Phi-2 están disponibles en HuggingFace en el formato safetensors. Dado que la API de LLM Inference solo admite LoRA en capas de atención, especifica solo 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 de acceso público que se ajustan a la API de inferencia de LLM 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 conjunto de datos preparado y guardar el modelo, obtienes un archivo adapter_model.safetensors que contiene los pesos del modelo LoRA ajustados. El archivo safetensors es el punto de control de LoRA que se usa en la conversión de modelos.

Como siguiente paso, debes convertir los pesos 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 convertidor generará dos archivos FlatBuffer de TFLite, uno para el modelo base y el otro para el modelo LoRA.

Inferencia de modelos de LoRA

Se actualizaron las APIs de inferencia de LLM de 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.