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 en el dispositivo a tus apps y productos.
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 de forma nativa, los usuarios pueden asignar otros modelos con las ofertas de AI Edge de Google (incluidos los modelos de asignación de PyTorch). Esto permite a los usuarios exportar un modelo asignado a modelos de TensorFlow Lite con varias firmas, que se agrupan con parámetros de tokenizador para crear un paquete de tareas.
Comenzar
Comienza a usar esta tarea siguiendo una de estas guías de implementación para tu plataforma de segmentación. 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:
Android:
iOS
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:
- Generación de texto a texto: Genera texto basado en una instrucción de texto de entrada.
- 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.
- Compatibilidad con LoRA: Extiende y personaliza la capacidad de LLM con el modelo LoRA entrenando todo tu conjunto de datos o tomando modelos LoRA preparados y precompilados 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:
|
La API de LLM Inference genera los siguientes resultados:
|
Opciones de configuración
Esta tarea tiene las siguientes opciones de configuración:
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 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 |
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 |
El valor inicial aleatorio que se usó durante la generación de texto. | Número entero | 0 |
loraPath |
Es la ruta de acceso absoluta al modelo de LoRA de forma local en el dispositivo. Nota: Esta función solo es compatible con los modelos de GPU. | PATH | N/A |
resultListener |
Establece el objeto de escucha de resultados para que reciba los resultados de forma asíncrona. Solo se aplica 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 |
Modelos
La API de LLM Inference contiene compatibilidad integrada con varios modelos grandes de lenguaje 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 LLM Inference, descarga uno de los modelos compatibles y almacena el archivo en el directorio de tu proyecto.
Gemma-2 2B
Gemma-2B es el modelo más reciente de la familia Gemma de modelos abiertos ligeros y de última generación creados 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. Gemma-2 2B se destaca por sus habilidades de razonamiento de vanguardia para los modelos de su clase.
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: Modelo de 8 bits de Gemma-2 2B compatible 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 de los modelos de Kaggle, el modelo ya está en el formato apropiado para usar con las tareas de MediaPipe.
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.
Los modelos Gemma 2B están disponibles en las siguientes variantes:
- gemma-2b-it-cpu-int4: Gemma 2B es un modelo de 4 bits 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: Modelo de 8 bits de Gemma 2B compatible con GPU.
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 Cómo ajustar Gemma. Después de descargar Gemma desde 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.
El modelo Gemma 7B viene en 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 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.
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 estará listo para convertirse al formato MediaPipe. Sigue los pasos que se indican en Cómo convertir un modelo al formato MediaPipe.
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.
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 Cómo convertir un modelo al formato MediaPipe.
Phi-2
Phi-2 es un modelo Transformer de 2,700 millones de parámetros. Se entrenó con textos sintéticos del PLN y sitios web filtrados. El modelo es más adecuado para instrucciones que usan el formato de pregunta-respuesta, chat y código.
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. Sigue los pasos que se indican en Cómo convertir un 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 la asignación y exportación de 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 Cómo convertir un modelo al formato MediaPipe.
Convertir el modelo al formato 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 de Kaggle, usa nuestras secuencias de comandos de conversión para dar formato al modelo para que sea compatible con MediaPipe.
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 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 las opciones del modelo base y otras opciones de LoRA. Ten en cuenta que, como la API solo admite la inferencia de LoRA con GPU, el backend se debe configurar 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.
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 safetensors del modelo se divide 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 . |
RUTA |
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", "GEMMA_7B", "GEMMA-2_2B"} |
backend |
Es el procesador (delegado) que se usa para ejecutar el modelo. | {"cpu", "gpu"} |
output_dir |
Es 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 `tflite` general. | PATH |
vocab_model_file |
Es la ruta de acceso al directorio que almacena los archivos tokenizer.json y tokenizer_config.json . Para Gemma, apunta al único archivo tokenizer.model . |
PATH |
lora_ckpt |
Es 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 el rango del punto de control de LoRA. Es obligatorio para convertir los pesos de Lora. Si no se proporciona, el convertidor supone que no hay pesos de LoRA. Nota: Solo el backend de GPU admite LoRA. | Número entero |
lora_output_tflite_file |
Es el nombre de archivo de salida de tflite 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 nuestra secuencia de comandos de agrupación para crear un paquete de tareas. El proceso de empaquetado une el modelo asignado con metadatos adicionales (p. ej., parámetros del tokenizador) 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)
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 |
Es el token de inicio específico del modelo. El token de inicio debe estar presente en el modelo de analizador proporcionado. | STRING |
stop_tokens |
Tokens de parada específicos del modelo Los tokens de parada deben estar presentes en el modelo de analizador proporcionado. | LIST[STRING] |
output_filename |
El nombre del archivo de paquete de tareas de salida. | PATH |
Personalización de LoRA
La API de inferencia de LLM de Mediapipe se puede configurar para admitir la adaptación de clasificación baja (LoRA) para modelos de lenguaje grande. Con modelos de LoRA ajustados, los desarrolladores pueden personalizar el comportamiento de los LLM a través de un proceso de entrenamiento rentable.La compatibilidad con LoRA de la API de LLM Inference funciona para los modelos Gemma-2B y Phi-2 para el backend de GPU, con pesos de LoRA que solo se aplican a las capas de atención. Esta implementación inicial funciona como una API experimental para desarrollos futuros 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 admitidos, Gemma-2B o Phi-2. Los modelos Gemma-2B y Phi-2 están disponibles en HuggingFace en el formato safetensors. 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 la 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 el modelo con el conjunto de datos preparado y guardarlo, obtendrás 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. El 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 de LoRA. La Web admite LoRA dinámico, que puede cambiar diferentes modelos de LoRA durante el tiempo de ejecución. Android y iOS admiten LoRA estático, que usa las mismas ponderaciones de LoRA durante la vida útil de la tarea.
Android admite LoRA estática durante la inicialización. Para cargar un modelo de LoRA, los usuarios especifican 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.