Introducing LiteRT: El entorno de ejecución de alto rendimiento de Google para la IA integrada en el dispositivo, antes conocido como TensorFlow Lite.

Se usó la API de Cloud Translation para traducir esta página.

Guía de inferencia de LLM para la Web

La API de inferencia de LLM te permite ejecutar modelos grandes de lenguaje (LLM) por completo en la navegador para aplicaciones web, que puedes usar para realizar una amplia gama de tareas, como generar texto, recuperar información en formato de lenguaje natural, y resumir documentos. La tarea proporciona compatibilidad integrada con varias modelos de lenguaje extensos de texto a texto, para que puedas aplicar modelos de IA generativa a tus apps web.

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

Ejemplo de código

La aplicación de ejemplo para la API de inferencia de LLM proporciona una implementación básica de esta tarea en JavaScript para tu referencia. Puedes usar esta app de ejemplo para obtener comencé a compilar tu propia app de generación de texto.

Puedes acceder a la app de ejemplo de la API de inferencia de LLM en GitHub.

Configuración

En esta sección, se describen los pasos clave para configurar tu entorno de desarrollo y proyectos de código específicamente para usar la API de inferencia de LLM. Para obtener información general configurar tu entorno de desarrollo para usar tareas de MediaPipe, incluidas requisitos de la versión de la plataforma, consulta la Guía de configuración de Web.

Compatibilidad del navegador

La API de inferencia de LLM requiere un navegador web compatible con WebGPU. Para obtener lista de navegadores compatibles, consulta Navegador de GPU compatibilidad.

Paquetes de JavaScript

El código de la API de inferencia de LLM está disponible a través del @mediapipe/tasks-genai . Puedes encontrar y descargar estas bibliotecas en los vínculos que se proporcionan en la la guía de configuración de la plataforma.

Instala los paquetes necesarios para la etapa de pruebas local:

npm install @mediapipe/tasks-genai

Para implementar en un servidor, usa un servicio de red de distribución de contenidos (CDN), como jsDelivr para agregar código directamente a tu página HTML:

<head>
  <script src="https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai/genai_bundle.cjs"
    crossorigin="anonymous"></script>
</head>

Modelo

La API de inferencia de MediaPipe LLM requiere un modelo entrenado que sea compatible con tarea. En las aplicaciones web, el modelo debe ser compatible con la GPU.

Para obtener más información sobre los modelos entrenados disponibles para la API de inferencia de LLM, consulta la tarea Descripción general de la sección Modelos.

Descarga un modelo

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: Parte de una familia de modelos abiertos ligeros y de última generación creados a partir del misma investigación y tecnología que se usó para crear la Modelos de Gemini. Son adecuados para una variedad de de generación de texto, como responder preguntas, resumir y el razonamiento. Descarga la variante de modelo Gemma 2B o Gemma 7B.
Phi-2: Parámetro de 2,700 millones Modelo Transformer, el más adecuado para preguntas y respuestas, chat y código de un conjunto de datos tengan un formato común.
Falcon-RW-1B: 1,000 millones modelo de solo decodificador causal de parámetros entrenado con 350,000 millones de tokens de RefinedWeb.
StableLM-3B: 3 mil millones de parámetros de un modelo de lenguaje solo con decodificador de parámetros previamente entrenados en 1 billón tokens de diversos conjuntos de datos en inglés y código.

Te recomendamos usar Gemma 2B o Gemma 7B, que están disponibles en Kaggle. modelos y vienen en un formato que ya es compatible con la API de inferencia de LLM. Si usas otro LLM, deberás convertir el modelo en un Formato compatible con MediaPipe. Para obtener más información sobre Gemma, consulta la sitio de Gemma. Para obtener más información sobre el otros modelos disponibles, consulta la sección Modelos en la descripción general de la tarea.

Convertir el modelo al formato MediaPipe

Conversión de modelo nativo

Si usas un LLM externo (Phi-2, Falcon o StableLM) o uno que no sea de Kaggle de Gemma, usemos los scripts de conversión para darle formato al modelo y son compatibles con MediaPipe.

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

Instala y, luego, importa las dependencias con el siguiente comando:

$ 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 el modelo base así como otras opciones 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 conversor generará dos archivos de búfer plano de TFLite, uno para el modelo base y el otro para el modelo LoRA.

Parámetro	Descripción	Valores aceptados
`input_ckpt`	La ruta de acceso al archivo `model.safetensors` o `pytorch.bin`. Ten en cuenta que, a veces, el formato de los protectores de modelos se fragmenta en varios archivos, p.ej., `model-00001-of-00003.safetensors` y `model-00001-of-00003.safetensors` Puedes especificar un patrón de archivo, como `model*.safetensors`.	RUTA
`ckpt_format`	El formato de archivo del modelo.	{"safetensors", "pytorch"}
`model_type`	El LLM que se está convirtiendo.	{"PHI_2", "FALCON_RW_1B", "STABLELM_4E1T_3B", "GEMMA_2B"}
`backend`	Es 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 ponderación por capa.	RUTA
`output_tflite_file`	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 `tflite` general.	RUTA
`vocab_model_file`	La ruta de acceso al directorio que almacena los elementos `tokenizer.json` y `tokenizer_config.json` archivos. Para Gemma, apunta al único archivo `tokenizer.model`.	RUTA
`lora_ckpt`	La ruta de acceso al ckpt de LoRA del archivo de tensores que almacena el peso del adaptador de LoRA.	RUTA
`lora_rank`	Un número entero que representa la clasificación de LoRA ckpt. Es obligatorio para convertir las ponderaciones de lora. Si no se proporcionan, el conversor supone que no hay ponderaciones de 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.	RUTA

Conversión de modelos de AI Edge

Si usas un LLM asignado a un modelo de TFLite a través de AI Edge, usa nuestro de paquetes de datos para crear un Paquete de tareas. El proceso de agrupación modelo asignado con metadatos adicionales (p.ej., parámetros del tokenizador) necesarios para ejecutar inferencias de extremo a extremo.

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

Instala y, luego, 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)

Parámetro	Descripción	Valores aceptados
`tflite_model`	La ruta de acceso al modelo de TFLite exportado de AI Edge.	RUTA
`tokenizer_model`	La ruta de acceso al modelo del tokenizador de SentencePiece.	RUTA
`start_token`	Token de inicio específico del modelo. El token de inicio debe estar presente en el modelo de tokenizador proporcionado.	STRING
`stop_tokens`	Tokens de parada específicos del modelo. Los tokens de parada deben estar presentes en la modelo de tokenizador proporcionado.	LISTA [STRING]
`output_filename`	El nombre del archivo de paquete de tareas de salida.	RUTA

Agrega el modelo al directorio del proyecto

Almacena el modelo en el directorio de tu proyecto:

<dev-project-root>/assets/gemma-2b-it-gpu-int4.bin

Especifica la ruta del modelo con el objeto modelAssetPath de baseOptions parámetro:

baseOptions: { modelAssetPath: `/assets/gemma-2b-it-gpu-int4.bin`}

Crea la tarea

Usa una de las funciones createFrom...() de la API de inferencia de LLM para preparar la tarea para ejecutar inferencias. Puedes usar la función createFromModelPath() con un relativa o absoluta al archivo del modelo entrenado. En el ejemplo de código, se usa el función createFromOptions(). Para obtener más información sobre los de configuración, consulta Opciones de configuración.

En el siguiente código, se muestra cómo compilar y configurar esta tarea:

const genai = await FilesetResolver.forGenAiTasks(
    // path/to/wasm/root
    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
llmInference = await LlmInference.createFromOptions(genai, {
    baseOptions: {
        modelAssetPath: '/assets/gemma-2b-it-gpu-int4.bin'
    },
    maxTokens: 1000,
    topK: 40,
    temperature: 0.8,
    randomSeed: 101
});

Opciones de configuración

Esta tarea tiene las siguientes opciones de configuración para apps web y de JavaScript:

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.	RUTA	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 tokens más probables de k superior.	Número entero	40
`temperature`	La cantidad de aleatorización que se introdujo durante la generación. Un valor superior temperatura da como resultado más creatividad en el texto generado, mientras que un una temperatura menor produce una generación más predecible.	Número de punto flotante	0.8
`randomSeed`	El valor inicial aleatorio que se usó durante la generación de texto.	Número entero	0
`loraRanks`	Clasificaciones de LoRA para que las usen los modelos LoRA durante el tiempo de ejecución. Nota: Esta función solo es compatible con los modelos de GPU.	Array de números enteros	N/A

Preparar los datos

La API de LLM Inference acepta datos de texto (string). La tarea maneja la entrada de datos el procesamiento previo, incluida la asignación de token y el procesamiento previo del tensor.

Todo el procesamiento previo se controla dentro de la función generateResponse(). Hay sin necesidad de realizar un procesamiento previo adicional del texto de entrada.

const inputPrompt = "Compose an email to remind Brett of lunch plans at noon on Saturday.";

Ejecuta la tarea

La API de inferencia de LLM usa la función generateResponse() para activar inferencias. Para la clasificación de texto, esto significa devolver las posibles categorías para el texto de entrada.

En el siguiente código, se muestra cómo ejecutar el procesamiento con la tarea un modelo de responsabilidad compartida.

const response = await llmInference.generateResponse(inputPrompt);
document.getElementById('output').textContent = response;

Para transmitir la respuesta, usa lo siguiente:

llmInference.generateResponse(
  inputPrompt,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});

Cómo controlar y mostrar resultados

La API de inferencia de LLM devuelve una cadena, que incluye el texto de respuesta generado.

Here's a draft you can use:

Subject: Lunch on Saturday Reminder

Hi Brett,

Just a quick reminder about our lunch plans this Saturday at noon.
Let me know if that still works for you.

Looking forward to it!

Best,
[Your Name]

Personalización del modelo LoRA

La API de inferencia de LLM de Mediapipe se puede configurar para admitir una adaptación de clasificación baja (LoRA) para modelos grandes de lenguaje. Con modelos de LoRA ajustados, los desarrolladores pueden personalizar el comportamiento de los LLM con un proceso de entrenamiento rentable

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

Prepara modelos de LoRA

Sigue las instrucciones de HuggingFace para entrenar un modelo LoRA ajustado en tu propio conjunto de datos con 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 tensores. Dado que la API de inferencia de LLM solo admite LoRA en las capas de atención, solo especifica capas de atención mientras creas el objeto 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, existen modelos de LoRA ajustados 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 LoRA ajustado. El archivo de tensores es el punto de control de LoRA que se usa en la conversión del modelo.

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

Inferencia del modelo LoRA

Se actualizó la API de LLM Inference para la Web, iOS y Android para admitir la inferencia del modelo LoRA. La 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 usa los mismos pesos de LoRA durante el ciclo de vida de la tarea.

La Web admite LoRA dinámica durante el tiempo de ejecución. Es decir, los usuarios declaran que las clasificaciones de LoRA se usarán durante la inicialización y pueden intercambiar distintos modelos de LoRA durante el tiempo de ejecución.

const genai = await FilesetResolver.forGenAiTasks(
    // path/to/wasm/root
    "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-genai@latest/wasm"
);
const llmInference = await LlmInference.createFromOptions(genai, {
    // options for the base model
    ...
    // LoRA ranks to be used by the LoRA models during runtime
    loraRanks: [4, 8, 16]
});

Durante el tiempo de ejecución, después de inicializar el modelo base, carga los modelos LoRA que se usarán. Además, activa el modelo LoRA pasando la referencia del modelo LoRA mientras se genera la respuesta del LLM.

// Load several LoRA models. The returned LoRA model reference is used to specify
// which LoRA model to be used for inference.
loraModelRank4 = await llmInference.loadLoraModel(loraModelRank4Url);
loraModelRank8 = await llmInference.loadLoraModel(loraModelRank8Url);

// Specify LoRA model to be used during inference
llmInference.generateResponse(
  inputPrompt,
  loraModelRank4,
  (partialResult, done) => {
        document.getElementById('output').textContent += partialResult;
});