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 LLM Inference te permite ejecutar modelos grandes de lenguaje (LLM) completamente en el dispositivo para aplicaciones web, 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 web.

Para agregar rápidamente la API de LLM Inference a tu aplicación web, sigue la Guía de inicio rápido. Para ver un ejemplo básico de una aplicación web que ejecuta la API de LLM Inference, consulta la aplicación de ejemplo. Para obtener una explicación más detallada del funcionamiento de la API de LLM Inference, consulta las secciones opciones de configuración, conversión de modelos y ajuste de LoRA.

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

Guía de inicio rápido

Sigue los pasos que se indican a continuación para agregar la API de LLM Inference a tu aplicación web. La API de LLM Inference requiere un navegador web con compatibilidad con WebGPU. Para obtener una lista completa de los navegadores compatibles, consulta Compatibilidad de navegadores con GPUs.

Cómo agregar dependencias

La API de LLM Inference usa el paquete @mediapipe/tasks-genai.

Instala los paquetes necesarios para la etapa de pruebas local:

npm install @mediapipe/tasks-genai

Para implementarlo 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>

Descarga un modelo

Descarga Gemma-2 2B en un formato cuantificado de 8 bits desde Modelos de Kaggle. Para obtener más información sobre los modelos disponibles, consulta la documentación de los modelos.

Almacena el modelo en el directorio de tu proyecto:

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

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

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

Inicializa la tarea

Inicializa la tarea con opciones de configuración básicas:

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-int8.bin'
    },
    maxTokens: 1000,
    topK: 40,
    temperature: 0.8,
    randomSeed: 101
});

Ejecuta la tarea

Usa la función generateResponse() para activar inferencias.

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;
});

Aplicación de ejemplo

La aplicación de ejemplo es un ejemplo de una app básica de generación de texto para la Web que usa la API de inferencia de LLM. Puedes usar la app como punto de partida para tu propia app web o consultarla cuando modifiques una app existente. El código de ejemplo se aloja en GitHub.

Clona el repositorio de git con el siguiente comando:

git clone https://github.com/google-ai-edge/mediapipe-samples

Para obtener más información, consulta la Guía de configuración para la Web.

Opciones de configuración

Usa las siguientes opciones de configuración para configurar una app web:

Nombre de la opción	Descripción	Rango de valores	Valor predeterminado
`modelPath`	Es la ruta de acceso a la ubicación en la que se almacena el modelo dentro del directorio del proyecto.	PATH	N/A
`maxTokens`	Es la cantidad máxima de tokens (tokens de entrada + tokens de salida) que controla el modelo.	Número entero	512
`topK`	Es la cantidad de tokens que considera el modelo en cada paso de generación. Limita las predicciones a los tokens más probables de Top-K.	Número entero	40
`temperature`	Es la cantidad de aleatoriedad que se introduce durante la generación. Una temperatura más alta genera más creatividad en el texto generado, mientras que una temperatura más baja produce una generación más predecible.	Número de punto flotante	0.8
`randomSeed`	Es la semilla aleatoria que se usa durante la generación de texto.	Número entero	0
`loraRanks`	Son las clasificaciones de LoRA que usarán los modelos de LoRA durante el tiempo de ejecución. Nota: Solo es compatible con modelos de GPU.	Array de números enteros	N/A

Conversión de modelos

La API de inferencia de LLM es compatible con los siguientes tipos 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.

Modelos	Método de conversión	Plataformas compatibles	File type
Gemma-3 1B	No se requiere una conversión	Android y Web	.task
Gemma 2B, Gemma 7B y Gemma 2 2B	No se requiere una conversión	Android, iOS y Web	.bin
Phi-2, StableLM y Falcon	Secuencia de comandos de conversión de MediaPipe	Android, iOS y Web	.bin
Todos los modelos de LLM de PyTorch	Biblioteca generativa de AI Edge Torch	Android, iOS	.task

Para obtener información sobre cómo convertir otros modelos, consulta la sección Conversión de modelos.

Personalización de LoRA

La API de Inference de LLM admite el ajuste de LoRA (adaptación de clasificación baja) con la biblioteca PEFT (ajuste fino eficiente en parámetros). El ajuste de LoRA personaliza el comportamiento de los LLM a través de un proceso de entrenamiento rentable, lo que crea un pequeño conjunto de pesos entrenables basados en datos de entrenamiento nuevos en lugar de volver a entrenar todo el modelo.

La API de inferencia de LLM admite la adición de ponderaciones de LoRA a las capas de atención de los modelos Gemma-2 2B, Gemma 2B y Phi-2. Descarga el modelo en formato safetensors.

El modelo de base debe estar en formato safetensors para crear pesos de LoRA. Después del entrenamiento de LoRA, puedes convertir los modelos al formato FlatBuffers para ejecutarlos en MediaPipe.

Prepara los pesos de LoRA

Usa la guía de métodos LoRA de PEFT para entrenar un modelo LoRA ajustado en tu propio conjunto de datos.

La API de LLM Inference solo admite LoRA en las capas de atención, por lo que solo debes especificar las capas de atención en LoraConfig:

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

Después de entrenar el conjunto de datos preparado y guardar el modelo, los pesos del modelo LoRA ajustados están disponibles en adapter_model.safetensors. El archivo safetensors es el punto de control de LoRA que se usa durante la conversión de modelos.

Conversión de modelos

Usa el paquete de Python de MediaPipe para convertir las ponderaciones del modelo en el formato Flatbuffer. ConversionConfig especifica las opciones del modelo base junto con las opciones adicionales de LoRA.

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

converter.convert_checkpoint(config)

El convertidor producirá dos archivos compatibles con MediaPipe, uno para el modelo base y otro para el modelo LoRA.

Inferencia de modelos de LoRA

La Web admite LoRA dinámico durante el tiempo de ejecución, lo que significa que los usuarios declaran las clasificaciones de LoRA durante la inicialización. Esto significa que puedes intercambiar diferentes 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]
});

Carga los modelos de LoRA durante el tiempo de ejecución, después de inicializar el modelo base. Activa el modelo de LoRA pasando la referencia del modelo cuando generes la respuesta de 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;
});