Guía de inferencia de LLM

La API de inferencia de LLM te permite ejecutar modelos grandes de lenguaje (LLM) completamente en el dispositivo, 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, de modo que puedas aplicar los modelos de IA generativa más recientes integrados en el dispositivo a tus apps y productos.

Probar

La tarea admite Gemma 2B y 7B, que forma parte de una familia de modelos abiertos de vanguardia y ligeros compilados a partir de la misma investigación y tecnología que se usaron para crear los modelos de Gemini. También es compatible con los siguientes modelos externos: Phi-2, Falcon-RW-1B y StableLM-3B.

Además de los modelos compatibles de forma nativa, los usuarios pueden asignar otros modelos con las ofertas de AI Edge de Google (incluida la asignación de modelos de PyTorch). Esto permite a los usuarios exportar un modelo asignado a modelos de TensorFlow Lite de varias firmas, que se empaquetan con parámetros de tokenizador para crear un paquete de tareas.

Comenzar

Comienza a utilizar esta tarea siguiendo una de estas guías de implementación para la plataforma de destino. En estas guías específicas de la plataforma, se explica la implementación básica de esta tarea, con ejemplos de código que usan un modelo disponible y las opciones de configuración recomendadas:

Detalles de la tarea

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

Funciones

La API de inferencia de LLM contiene las siguientes funciones clave:

  1. Generación de texto a texto: Genera texto basado en 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: Amplía y personaliza la capacidad del LLM con el modelo de LoRA entrenando todo el conjunto de datos o tomando modelos LoRA ya compilados y preparados de la comunidad de código abierto (solo modelos nativos).
Entradas de tareas Resultados de la tarea
La API de inferencia de LLM acepta las siguientes entradas:
  • Instrucción de texto (p.ej., una pregunta, el asunto de un correo electrónico o un documento para resumir)
 La API de inferencia de LLM genera los siguientes resultados:
  • Texto generado basado en la instrucción de entrada (p.ej., una respuesta a la pregunta, un borrador de correo electrónico o un resumen del documento)

Opciones de configuración

Esta tarea incluye las siguientes opciones de configuración:

Nombre de la opción Descripción Rango de valores Valor predeterminado
modelPath La ruta de acceso en la que se almacena el modelo dentro del directorio del proyecto. PATH N/A
maxTokens La cantidad máxima de tokens (tokens de entrada + tokens de salida) que controla el modelo. Número entero 512
topK La cantidad de tokens que el modelo considera en cada paso de generación. Limita las predicciones a los k tokens más probables principales. Cuando configuras topK, también debes establecer un valor para randomSeed. Número entero 40
temperature La cantidad de aleatoriedad introducida durante la generación. Una temperatura más alta da como resultado más creatividad en el texto generado, mientras que una temperatura más baja produce una generación más predecible. Cuando configuras temperature, también debes establecer un valor para randomSeed. Número de punto flotante 0.8
randomSeed El valor inicial aleatorio usado durante la generación de texto. Número entero 0
loraPath Es la ruta de acceso absoluta al modelo de LoRA local en el dispositivo. Nota: Esto solo es compatible con los modelos de GPU. PATH N/A
resultListener Configura el objeto de escucha de resultados para recibir los resultados de forma asíncrona. Solo es aplicable cuando se usa el método de generación asíncrona. N/A N/A
errorListener Establece un objeto de escucha de errores opcional. N/A N/A

ajustables

La API de inferencia de LLM contiene compatibilidad integrada con modelos grandes de lenguaje divisores de texto a texto que están optimizados para ejecutarse en navegadores y dispositivos móviles. Estos modelos ligeros se pueden descargar para ejecutar inferencias completamente en el dispositivo.

Antes de inicializar la API de inferencia de LLM, descarga uno de los modelos compatibles y almacena el archivo dentro del directorio de tu proyecto.

Gemma 2B

Gemma 2B es parte de una familia de modelos abiertos de vanguardia y ligeros 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 pesos abiertos. Este modelo es adecuado para una variedad de tareas de generación de texto, como la respuesta de preguntas, el resumen y el razonamiento.

Descargar Gemma 2B

Los modelos de Gemma 2B vienen en cuatro variantes:

También puedes ajustar el modelo y agregar nuevos pesos antes de agregarlo a la app. Para obtener más información sobre el ajuste y la personalización de Gemma, consulta Ajuste de Gemma. Después de descargar Gemma desde los modelos Kaggle, el modelo ya tiene el formato adecuado para usar con MediaPipe.

Si descargas Gemma 2B de Hugging Face, debes convertir el modelo a un formato compatible con MediaPipe. La API de inferencia de LLM requiere que se descarguen y conviertan los siguientes archivos:

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

Gemma 7B

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

Descargar Gemma 7B

El modelo Gemma 7B viene en una variante:

Si descargas Gemma 7B de Hugging Face, debes convertir el modelo a un formato compatible con MediaPipe. La API de inferencia de LLM requiere que se descarguen y conviertan los siguientes archivos:

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

Falcon 1B

Falcon-1B es un modelo causal solo de decodificador de 1,000 millones de parámetros entrenado con 350,000 millones de tokens de RefinedWeb.

Descargar Falcon 1B

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

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

Después de descargar los archivos de modelo de Falcon, el modelo está listo para convertirse al formato MediaPipe. Sigue los pasos que se indican en Convierte el modelo al formato MediaPipe.

StableLM 3B

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

Descargar StableLM 3B

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

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

Después de descargar los archivos del modelo StableLM, el modelo está listo para convertirse al formato MediaPipe. Sigue los pasos que se indican en Convierte el modelo al formato MediaPipe.

Phi-2

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

Descargar Phi-2

La API de inferencia de LLM requiere que los siguientes archivos se descarguen y almacenen 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. Sigue los pasos que se indican en Convierte el modelo al formato MediaPipe.

Modelos exportados de AI Edge

AI Edge es una oferta de Google que te permite convertir modelos asignados por el usuario en modelos de TensorFlow Lite con varias firmas. Para obtener más detalles sobre cómo asignar y exportar modelos, visita la página de GitHub de AI Edge Torch.

Después de exportar el modelo al formato TFLite, el modelo está listo para convertirse al formato MediaPipe. Para obtener más información, consulta Convierte el modelo al formato de MediaPipe.

Convierte el modelo a formato de MediaPipe

Conversión de modelos nativos

Si usas un LLM externo (Phi-2, Falcon o StableLM) o una versión de Gemma que no sea Kaggle, usa nuestras secuencias de comandos de conversión para formatear el modelo y que sea compatible con MediaPipe.

El proceso de conversión del modelo 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 e 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 de LoRA, ConversionConfig debe especificar las opciones del modelo base, así como las opciones de LoRA adicionales. Ten en cuenta que, como la API solo admite inferencias de LoRA con GPU, el backend debe configurarse 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 de búfer plano de TFLite, uno para el modelo base y otro para el modelo de LoRA.

Parámetro Descripción Valores aceptados
input_ckpt Es la ruta de acceso al archivo model.safetensors o pytorch.bin. Ten en cuenta que, a veces, el formato de los Safetensors del modelo se fragmenta en varios archivos, p.ej., model-00001-of-00003.safetensors, model-00001-of-00003.safetensors. Puedes especificar un patrón de archivo, como model*.safetensors. PATH
ckpt_format El formato de archivo del modelo. {"safetensors", "pytorch"}
model_type El LLM que se convertirá. {“PHI_2”, “FALCON_RW_1B”, “STABLELM_4E1T_3B”, “GEMMA_2B"}
backend El procesador (delegado) que se usa para ejecutar el modelo. {"cpu", "gpu"}
output_dir La ruta de acceso al directorio de salida que aloja los archivos de peso por capa. PATH
output_tflite_file Es la ruta de acceso al archivo de salida. Por ejemplo, "model_cpu.bin" o "model_gpu.bin". Este archivo solo es compatible con la API de inferencia de LLM y no se puede usar como un archivo general “tflite”. PATH
vocab_model_file Es la ruta de acceso al directorio que almacena los archivos tokenizer.json y tokenizer_config.json. En Gemma, selecciona el único archivo tokenizer.model. PATH
lora_ckpt La ruta de acceso al archivo ckpt de LoRA de Safetensors que almacena el peso del adaptador de LoRA. PATH
lora_rank Es un número entero que representa la clasificación de ckpt de LoRA. Obligatorio para convertir las ponderaciones de lora. Si no se proporcionan, el conversor considera que no hay ponderaciones de la LoRA. Nota: Solo el backend de GPU es compatible con LoRA. Número entero
lora_output_tflite_file Nombre de archivo de tflite de salida para las ponderaciones de LoRA. PATH

Conversión de modelos de AI Edge

Si usas un LLM asignado a un modelo de TFLite a través de AI Edge, usa nuestra secuencia de comandos de paquetes para crear un paquete de tareas. El proceso de creación de paquetes empaqueta el modelo asignado con metadatos adicionales parámetros del tokenizador) necesarios para ejecutar inferencias de extremo a extremo.

El proceso de agrupamiento del modelo 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 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)
Parámetro Descripción Valores aceptados
tflite_model La ruta de acceso al modelo de TFLite exportado de AI Edge. PATH
tokenizer_model La ruta de acceso al modelo del tokenizador de SentencePiece. PATH
start_token Token de inicio específico del modelo. El token de inicio debe estar presente en el modelo de asignación de tokens proporcionado. STRING
stop_tokens Modela tokens de parada específicos. Los tokens de detención deben estar presentes en el modelo de asignación de tokens proporcionado. LISTA[STRING]
output_filename Es el nombre del archivo de paquete de tareas de salida. PATH

Personalización de la LoRA

La API de inferencia de LLM de Mediapipe se puede configurar para que admita la adaptación de bajo rango (LoRA) en modelos grandes de lenguaje. Mediante modelos de LoRA ajustados, los desarrolladores pueden personalizar el comportamiento de los LLM a través de un proceso de entrenamiento rentable.

La compatibilidad de LoRA con la API de inferencia de LLM funciona con los modelos Gemma-2B y Phi-2 para el backend de la GPU, y las ponderaciones de LoRA se aplican solo a las capas de atención. Esta implementación inicial sirve 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 de LoRA

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

# For Gemma-2B
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 de LoRA perfeccionados y de acceso público que se ajustan a la API de inferencia de LLM disponibles 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 con el conjunto de datos preparado y guardar el modelo, obtendrás un archivo adapter_model.safetensors que contiene los pesos del modelo de LoRA ajustados. El archivo Safetensors es el punto de control de la LoRA que se usa en la conversión del modelo.

En el siguiente paso, debes convertir los pesos del modelo en un búfer plano de TensorFlow Lite con el paquete de MediaPipe para Python. El ConversionConfig debe especificar las opciones del modelo base, así como las opciones de LoRA adicionales. Ten en cuenta que, como la API solo admite la inferencia de LoRA con GPU, el backend debe configurarse 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 de búfer plano de TFLite, uno para el modelo base y otro para el modelo de LoRA.

Inferencia del modelo de LoRA

Se actualizaron las APIs de inferencia de LLM para iOS, Android y la Web para admitir la inferencia de modelos de LoRA. Web admite LoRA dinámica, que puede cambiar diferentes modelos de LoRA durante el tiempo de ejecución. iOS y Android admiten la LoRA estática, que utiliza las mismas ponderaciones de la LoRA durante el ciclo de vida de la tarea.

Android admite la LoRA estática durante la inicialización. Para cargar un modelo de LoRA, los usuarios deben especificar la ruta de acceso del modelo de LoRA y el LLM base.

// 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.