La API de inferencia de LLM te permite ejecutar modelos grandes de lenguaje (LLM) por completo integrado 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 varias modelos de lenguaje extensos de texto a texto, para que puedas aplicar modelos de IA generativa para tus apps y productos.
La tarea admite Gemma 2B y 7B, como parte de una familia de modelos abiertos ligeros y de última generación creados a partir de la misma la investigación y la tecnología que se usan para crear Gemini e implementar modelos automáticamente. 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 con AI Edge de Google ofertas (incluidas asignar modelos de PyTorch). Esto permite a los usuarios exportar un modelo asignado a modelos de firmas múltiples Los modelos de TensorFlow Lite, que se agrupan con los parámetros del 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 destino. Estas guías específicas para plataformas te guiarán a través de un implementación de la 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 la configuración opciones de esta tarea.
Funciones
La API de inferencia de LLM 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 tu casos de uso específicos. También puedes volver a entrenar y aplicar pesos personalizados al un modelo de responsabilidad compartida.
- Compatibilidad con LoRA: Extiende y personaliza la capacidad de los LLM con el modelo LoRA. ya sea entrenando con todo el conjunto de datos o realizando un LoRA compilado previamente de la comunidad de código abierto (solo para modelos nativos).
Entradas de tareas | Resultados de la tarea |
---|---|
La API de inferencia de LLM acepta las siguientes entradas:
|
La API de inferencia de LLM 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 |
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 |
loraPath |
La ruta de acceso absoluta al modelo LoRA a nivel local en el dispositivo. Nota: Esta función solo es compatible con los modelos de GPU. | RUTA | N/A |
resultListener |
Configura el objeto de escucha de resultados para recibir los resultados de manera asíncrona. Solo es aplicable cuando se usa el método de generación asíncrona. | N/A | N/A |
errorListener |
Configura un objeto de escucha de errores opcional. | N/A | N/A |
Modelos
La API de inferencia de LLM tiene compatibilidad integrada con bloques de texto de lenguaje natural que están optimizados para ejecutarse en navegadores y dispositivos móviles. Estos los 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 almacenas el archivo dentro del directorio de tu proyecto.
Gemma 2B
Gemma 2B forma parte de una familia de modelos abiertos ligeros de última generación creados a partir de la misma investigación y tecnología que se usa para crear los modelos de Gemini. El contiene 2,000 millones de parámetros y pesos abiertos. Este modelo es adecuado para varias tareas de generación de texto, como responder preguntas, resumir, y razonamiento.
Los modelos de Gemma 2B vienen en cuatro variantes:
- gemma-2b-it-cpu-int4: Modelo Gemma 2B de 4 bits compatible con CPU.
- gemma-2b-it-cpu-int8: Modelo Gemma 2B de 8 bits compatible con CPU.
- gemma-2b-it-gpu-int4: Modelo Gemma 2B de 4 bits compatible con GPU.
- gemma-2b-it-gpu-int8: Modelo Gemma 2B de 8 bits compatible con GPU.
También puedes ajustar el modelo y agregar nuevos pesos antes de agregarlo a la app. Para 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 de los modelos de Kaggle, haz lo siguiente: el modelo ya tiene el formato adecuado para usarlo 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 se 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 más grande de Gemma con 7B. parámetros y ponderaciones abiertas. El modelo es más potente para una variedad de textos tareas de generación de demanda, como responder preguntas, resumir y razonar. Gemma 7B solo es compatible con la versión web.
El modelo Gemma 7B viene en una variante:
- gemma-1.1-7b-it-gpu-int8: Modelo Gemma 7B de 8 bits compatible con GPU.
Si descargas Gemma 7B de Hugging Face, sigue estos pasos: Debes convertir el modelo en un formato compatible con MediaPipe. El 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 de 1,000 millones de parámetros solo de decodificador causal entrenado en 350B tokens de RefinedWeb.
La API de LLM Inference requiere que se descarguen y almacenen los siguientes archivos localmente:
tokenizer.json
tokenizer_config.json
pytorch_model.bin
Después de descargar los archivos del modelo Falcon, el modelo está listo para convertirse en el formato MediaPipe. Sigue los pasos que se indican en Cómo convertir el modelo en MediaPipe. formato.
StableLM 3B
StableLM-3B es un modelo de lenguaje de 3,000 millones de parámetros solo con decodificadores previamente entrenados 1 billón de tokens de diversos conjuntos de datos en inglés y de código para 4 ciclos de entrenamiento
La API de LLM Inference requiere que se descarguen y almacenen los siguientes archivos localmente:
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 el modelo en MediaPipe. formato.
Phi-2
Phi-2 es un modelo Transformer de 2,700 millones de parámetros. Se entrenó usando varios Textos sintéticos de PLN y sitios web filtrados El modelo es el más adecuado para instrucciones con el formato de pregunta-respuesta, chat y código.
La API de LLM Inference requiere que se descarguen y almacenen los siguientes archivos localmente:
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 a el formato MediaPipe. Sigue los pasos que se indican en Cómo convertir el modelo en MediaPipe. formato.
Modelos exportados de AI Edge
AI Edge es una oferta de Google que te permite convertir modelos asignados por usuarios en modelos de TensorFlow Lite con varias firmas. Para obtener más detalles sobre la asignación y exportar modelos, visita AI Edge Torch Página de GitHub.
Después de exportar el modelo al formato TFLite, está listo para usarse se convierten al formato MediaPipe. Para obtener más información, consulta Convierte el modelo al formato MediaPipe.
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 |
Personalización de 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 rentableLa 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.
Android admite LoRA estática durante la inicialización. Para cargar un modelo LoRA, los usuarios especifican la ruta del modelo LoRA, así como 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.