Implementar modelos de lenguaje grandes en dispositivos Android es una tarea compleja ya que estos modelos a menudo requieren amplios recursos informáticos. Primero, debe cargar y optimizar el modelo, luego elegir un motor de inferencia adecuado y finalmente integrarlo en su aplicación de Android. Estos son los pasos generales:
1. Cargue y optimice el modelo:
- Si ha creado un modelo de lenguaje grande utilizando Keras, primero debe cargar el modelo en Python.
- Convierta el modelo al formato TensorFlow Lite utilizando las herramientas de conversión de TensorFlow, como TensorFlow Lite Converter, que puede reducir el tamaño del modelo y mejorar el rendimiento en dispositivos móviles.
- Los modelos también se pueden comprimir utilizando técnicas de cuantificación para reducir los requisitos computacionales y de memoria.
2. Seleccione un motor de inferencia:
- Para ejecutar modelos en dispositivos Android es necesario elegir un motor de inferencia adecuado. TensorFlow Lite y ONNX Runtime son opciones comunes para ejecutar varios tipos de modelos en Android.
- Evalúe el rendimiento de diferentes motores y elija el que mejor se adapte a su modelo y necesidades de aplicación.
3. Integrar en aplicaciones de Android:
- Cree un proyecto de aplicación de Android e integre los archivos del modelo y el motor de inferencia en el proyecto.
- Utilice Android Studio para desarrollar interfaces de aplicaciones para que los usuarios puedan interactuar con el modelo.
- Configure un canal de inferencia en su aplicación para procesar la entrada del usuario y obtener el resultado del modelo.
4. Optimice el rendimiento:
- La ejecución de modelos de lenguaje grandes en dispositivos móviles puede causar problemas de rendimiento, especialmente requisitos de memoria y computacionales.
- Optimice la inferencia del modelo, como el procesamiento por lotes de entradas, la reducción del uso de memoria, el uso de aceleración de GPU, etc.
- Considere la posibilidad de utilizar el almacenamiento en caché de modelos para evitar la carga repetida de modelos.
5. Pruebas y depuración:
- Pruebe en dispositivos reales para garantizar que el modelo funcione bien en dispositivos móviles.
- Realice análisis de rendimiento y depuración para resolver cualquier problema de rendimiento o funcionalidad.
6. Seguridad y Privacidad:
- Implemente las medidas de seguridad y privacidad necesarias en sus aplicaciones, especialmente cuando maneje datos confidenciales.
- Garantizar el almacenamiento y la transmisión seguros de modelos y datos.
7. Publicar la solicitud:
- Prepare la aplicación para publicarla en Google Play Store u otras tiendas de aplicaciones apropiadas.
Tenga en cuenta que esta es una tarea avanzada y requiere un conocimiento profundo del desarrollo de aplicaciones móviles y el aprendizaje profundo. Es posible que necesite obtener más información sobre el desarrollo de Android, TensorFlow Lite u ONNX Runtime, y técnicas de optimización de modelos para implementar con éxito modelos de lenguaje grandes en dispositivos Android. Al mismo tiempo, garantice el cumplimiento de las regulaciones y políticas de privacidad pertinentes para proteger los datos de los usuarios.
Ejemplos relacionados
Uno de los avances recientes más interesantes en el aprendizaje automático son los modelos de lenguajes grandes (LLM). Estos modelos se pueden utilizar para generar texto, traducir idiomas y responder preguntas de manera integral e informativa. Los LLM como Google LaMDA y PaLM han sido capacitados con grandes cantidades de datos de texto, lo que les permite aprender patrones estadísticos y relaciones entre palabras y frases. De esta manera, pueden producir textos que se asemejan a la escritura humana y pueden traducirse con gran precisión.
Los LLM ocupan mucho espacio de almacenamiento y a menudo requieren mucha potencia informática para ejecutarse, lo que significa que a menudo se implementan en la nube y son extremadamente desafiantes para el aprendizaje automático en el dispositivo (ODML) debido a la potencia informática limitada de los dispositivos móviles. .sexo. Sin embargo, también puede ejecutar LLM de menor escala (como GPT-2) en dispositivos Android más nuevos y aun así lograr resultados impresionantes.
En este codelab, aprenderá a crear una aplicación impulsada por LLM mediante:
- Cargue LLM previamente entrenado (GPT-2) usando KerasNLP
- Ajuste fino de LLM (GPT-2) usando KerasNLP
- Convierta, optimice e implemente LLM en Android usando TensorFlow Lite
Requisitos previos
- Conocimiento intermedio de Keras y TensorFlow Lite.
- Domina los conceptos básicos del desarrollo de Android.
Contenido de aprendizaje
- Cómo cargar y ajustar LLM previamente capacitado usando KerasNLP
- Cómo cuantificar LLM y convertirlo a TensorFlow Lite
- Cómo utilizar el modelo convertido de TensorFlow Lite para inferencia
Acerca de KerasNLP
KerasNLP es una biblioteca de procesamiento de lenguaje natural que apoya a los usuarios durante todo su ciclo de desarrollo. Nuestros flujos de trabajo se construyen a partir de componentes modulares que vienen con arquitecturas y pesos preestablecidos de última generación listos para usar y se pueden personalizar fácilmente cuando se necesita más control. Hacemos hincapié en el cálculo en gráficos para todos los flujos de trabajo para que los desarrolladores puedan implementar fácilmente la producción utilizando el ecosistema TensorFlow. La biblioteca es una extensión de la API principal de Keras; todos los módulos y capas avanzados reciben modelos con el mismo nivel de pulido que el núcleo de Keras.
- Entorno de instalación
pip install git+https://github.com/keras-team/keras-nlp.git --upgrade
- Inicio rápido
Utilice la API para ajustar BERT keras_nlp.models para pequeñas tareas de análisis de sentimientos:
import keras_nlp
import tensorflow_datasets as tfds
imdb_train, imdb_test = tfds.load(
"imdb_reviews",
split=["train", "test"],
as_supervised=True,
batch_size=16,
)
# Load a BERT model.
classifier = keras_nlp.models.BertClassifier.from_preset("bert_base_en_uncased")
# Fine-tune on IMDb movie reviews.
classifier.fit(imdb_train, validation_data=imdb_test)
# Predict two new examples.
classifier.predict(["What an amazing movie!", "A total waste of my time."])
Implementar LLM en el lado del dispositivo
Uso de aplicaciones de Android
- Github : ejemplos/lite/ejemplos/generative_ai
Inicializar el modelo
El método initModel se utiliza para inicializar el modelo TensorFlow-Lite. Primero intenta cargar el archivo del modelo y luego crea una instancia de un objeto Intérprete para ejecutar el modelo.
override suspend fun initModel(): InitModelResult {
return withContext(dispatcher) {
// Load model file
val loadResult = loadModelFile(context)
// Determine if load was successful
if (loadResult.isFailure) {
val exc = loadResult.exceptionOrNull()
return@withContext if (exc is FileNotFoundException) {
InitModelResult.Error(AutoCompleteServiceError.MODEL_FILE_NOT_FOUND)
} else {
InitModelResult.Error(AutoCompleteServiceError.MODEL_NOT_INITIALIZED)
}
}
// Instantiate interpreter with loaded model
val model = loadResult.getOrNull()
isInitialized = model?.let {
interpreter = Interpreter(it)
true
} ?: false
if (isInitialized) InitModelResult.Success
else InitModelResult.Error(AutoCompleteServiceError.MODEL_NOT_INITIALIZED)
}
}
Ejecute el modelo
El método runInterpreterOn se utiliza para ejecutar el modelo TensorFlow-Lite y generar texto nuevo basado en el texto de entrada.
@WorkerThread
private fun runInterpreterOn(input: String): String {
outputBuffer.clear()
// Run interpreter, which will generate text into outputBuffer
interpreter.run(input, outputBuffer)
// Set output buffer limit to current position & position to 0
outputBuffer.flip()
// Get bytes from output buffer
val bytes = ByteArray(outputBuffer.remaining())
outputBuffer.get(bytes)
outputBuffer.clear()
// Return bytes converted to String
return String(bytes, Charsets.UTF_8)
}
guía del usuario
Paso 1. Entrenar el modelo de lenguaje usando Keras
En esta demostración, usaremos KerasNLP para obtener el modelo GPT-2. KerasNLP es una biblioteca que contiene modelos previamente entrenados de última generación para tareas de procesamiento del lenguaje natural y apoya a los usuarios durante todo su ciclo de desarrollo. Puede ver la lista de modelos disponibles en el repositorio de KerasNLP. Los flujos de trabajo se crean a partir de componentes modulares que vienen con arquitecturas y pesos preestablecidos de última generación listos para usar y se pueden personalizar fácilmente cuando se necesita más control. La creación de un modelo GPT-2 se puede lograr siguiendo estos pasos:
gpt2_tokenizer = keras_nlp.models.GPT2Tokenizer.from_preset("gpt2_base_en")
gpt2_preprocessor = keras_nlp.models.GPT2CausalLMPreprocessor.from_preset(
"gpt2_base_en",
sequence_length=256,
add_end_token=True,
)
gpt2_lm = keras_nlp.models.GPT2CausalLM.from_preset(
"gpt2_base_en",
preprocessor=gpt2_preprocessor,
)
Puede ver la implementación completa del modelo GPT-2 en GitHub.
Paso 2. Convertir el modelo Keras al modelo TFLite
generate() comienza desde la función GPT2CausalLM que realiza la conversión. Envuelva la función generate() para crear una función TensorFlow concreta:
@tf.function
def generate(prompt, max_length):
# prompt: input prompt to the LLM in string format
# max_length: the max length of the generated tokens
return gpt2_lm.generate(prompt, max_length)
concrete_func = generate.get_concrete_function(tf.TensorSpec([], tf.string), 100)
Ahora defina una función auxiliar que ejecutará la inferencia utilizando la entrada y el modelo TFLite. Las operaciones de texto de TensorFlow no son operaciones integradas en el tiempo de ejecución de TFLite, por lo que debes agregar estas operaciones personalizadas para que el intérprete razone sobre este modelo. Esta función auxiliar acepta entradas y una función para realizar la transformación, es decir, la función generador() definida anteriormente.
def run_inference(input, generate_tflite):
interp = interpreter.InterpreterWithCustomOps(
model_content=generate_tflite,
custom_op_registerers=tf_text.tflite_registrar.SELECT_TFTEXT_OPS)
interp.get_signature_list()
generator = interp.get_signature_runner('serving_default')
output = generator(prompt=np.array([input]))
Ahora puedes convertir el modelo:
gpt2_lm.jit_compile = False
converter = tf.lite.TFLiteConverter.from_concrete_functions(
[concrete_func],
gpt2_lm)
converter.target_spec.supported_ops = [
tf.lite.OpsSet.TFLITE_BUILTINS, # enable TFLite ops
tf.lite.OpsSet.SELECT_TF_OPS, # enable TF ops
]
converter.allow_custom_ops = True
converter.target_spec.experimental_select_user_tf_ops = [
"UnsortedSegmentJoin",
"UpperBound"
]
converter._experimental_guarantee_all_funcs_one_use = True
generate_tflite = converter.convert()
run_inference("I'm enjoying a", generate_tflite)
Paso 3. Cuantización
TensorFlow Lite implementa una técnica de optimización llamada cuantificación que puede reducir el tamaño del modelo y acelerar la inferencia. A través del proceso de cuantificación, los números de punto flotante de 32 bits se asignan a enteros más pequeños de 8 bits, reduciendo así el tamaño del modelo en un factor de 4 para una ejecución más eficiente en hardware moderno. Hay muchas formas de realizar la cuantización en TensorFlow. Puede visitar las páginas TFLite Model Optimization y TensorFlow Model Optimization Toolkit para obtener más información. Los tipos de cuantificación se explican brevemente a continuación.
Aquí utilizará la cuantificación de rango dinámico posterior al entrenamiento en el modelo GPT-2 configurando el indicador de optimización del convertidor en tf.lite.Optimize.DEFAULT, y el resto del proceso de conversión es el mismo que se detalló anteriormente. Nuestras pruebas encontraron que al utilizar esta técnica de cuantificación, con la duración máxima de salida establecida en 100, la latencia en el Pixel 7 fue de aproximadamente 6,7 segundos.
gpt2_lm.jit_compile = False
converter = tf.lite.TFLiteConverter.from_concrete_functions(
[concrete_func],
gpt2_lm)
converter.target_spec.supported_ops = [
tf.lite.OpsSet.TFLITE_BUILTINS, # enable TFLite ops
tf.lite.OpsSet.SELECT_TF_OPS, # enable TF ops
]
converter.allow_custom_ops = True
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.experimental_select_user_tf_ops = [
"UnsortedSegmentJoin",
"UpperBound"
]
converter._experimental_guarantee_all_funcs_one_use = True
quant_generate_tflite = converter.convert()
run_inference("I'm enjoying a", quant_generate_tflite)
with open('quantized_gpt2.tflite', 'wb') as f:
f.write(quant_generate_tflite)
Paso 4. Integración de la aplicación de Android
Puede clonar este repositorio y reemplazarlo android/app/src/main/assets/autocomplete.tflitecon el archivo quant_generate_tflite convertido.
Referencias relacionadas
Modelos de lenguaje a gran escala en el dispositivo que utilizan Keras y TensorFlow Lite
https://codelabs.developers.google.com/kerasnlp-tflite