Ajuste modelos multimodales grandes con Amazon SageMaker

Los grandes modelos multimodales (LMM) integran múltiples tipos de datos en un solo modelo. Al combinar datos de texto con imágenes y otras modalidades durante el entrenamiento, los modelos multimodales como Claude3, GPT-4V y Gemini Pro Vision obtienen una comprensión más completa y una capacidad mejorada para procesar diversos tipos de datos. El enfoque multimodal permite que los modelos manejen una gama más amplia de tareas del mundo real que involucran entradas de texto y no textuales. De esta manera, la multimodalidad ayuda a superar las restricciones de los modelos de texto puro. Los LMM tienen el potencial de tener un impacto profundo en diversas industrias, como la atención médica, el análisis empresarial, la conducción autónoma, etc.

Sin embargo, un modelo de lenguaje de propósito general sólo puede procesar tareas visuales relativamente simples, como responder preguntas básicas sobre una imagen o generar subtítulos breves. Esto se debe principalmente a la falta de acceso a información detallada a nivel de píxeles, datos de segmentación de objetos y otras anotaciones granulares que permitirían al modelo comprender y razonar con precisión los diversos elementos, relaciones y contexto dentro de una imagen. Sin esta comprensión visual detallada, el modelo de lenguaje se limita a capacidades de generación y análisis más superficiales y de alto nivel relacionadas con las imágenes. Ajustar los LMM en datos específicos de dominio puede mejorar significativamente su rendimiento para tareas específicas. La perspectiva de perfeccionar modelos multimodales de código abierto como LLaVA es muy atractiva debido a su rentabilidad, escalabilidad y rendimiento impresionante en puntos de referencia multimodales. Para quienes buscan soluciones flexibles y económicas, la capacidad de utilizar y personalizar estos potentes modelos tiene un inmenso potencial.

En esta publicación de blog, demostramos cómo ajustar e implementar el la lava modelo en amazon SageMaker. El código fuente está disponible en este amazon-sagemaker-finetune-deploy-llava-huggingface” target=”_blank” rel=”noopener”>GitHub repositorio.

Descripción general de LLaVA

LLaVA está capacitado de un extremo a otro para permitir la comprensión de propósito general a través de datos visuales y textuales. En la arquitectura del modelo LLaVA, los modelos de lenguaje previamente entrenados, como Vicuna o LLaMA, se combinan con modelos visuales como el codificador visual de CLIP. La integración convierte las características visuales de las imágenes a un formato que coincide con las incrustaciones del modelo de lenguaje a través de una capa de proyección.

El entrenamiento de LLaVA ocurre en dos etapas, como se muestra en la Figura 1 a continuación. La primera etapa es el entrenamiento previo, que utiliza pares de imagen y texto para alinear las características visuales con las incrustaciones del modelo de lenguaje. En esta etapa, los pesos del codificador visual y del modelo de lenguaje se mantienen congelados y solo se entrena la matriz de proyección. La segunda etapa consiste en ajustar todo el modelo de un extremo a otro. Aquí, los pesos del codificador visual se congelan, mientras que la capa de proyección y el modelo de lenguaje se actualizan.

Figura 1: Arquitectura LLaVA

preparar datos

Cuando se trata de ajustar el modelo LLaVA para tareas o dominios específicos, la preparación de datos es de suma importancia porque tener anotaciones integrales y de alta calidad permite que el modelo aprenda representaciones ricas y logre un rendimiento a nivel humano en desafíos complejos de razonamiento visual. En esta publicación, nos centramos en preparar un conjunto de datos de instrucciones.

Anotación de datos

El conjunto de datos debe contener pares de imágenes y texto que impliquen razonamiento para responder preguntas sobre imágenes. Para ayudar al modelo a obtener una comprensión integral durante el proceso de capacitación, los datos del texto deben enriquecerse con matices contextuales. Por ejemplo, en lugar de simplemente pedirle al modelo que describa la imagen, haga preguntas específicas sobre la imagen y su contenido.

Para demostrar las capacidades de LLaVA, creamos un pequeño conjunto de datos sintéticos centrado en comprender e interpretar infografías y gráficos. Usamos amazon Bedrock y Python para esta tarea. Específicamente, empleamos el modelo amazon Bedrock LLaMA2-70B para generar descripciones de texto y pares de preguntas y respuestas basados ​​en esas descripciones. Posteriormente, utilizamos Python para generar diferentes tipos de presentaciones visuales, como gráficos circulares y gráficos de embudo, basados ​​en las descripciones de texto. Si ya tiene un conjunto de datos existente, este método se puede utilizar como técnica de aumento de datos para expandir su conjunto de datos y potencialmente mejorar el resultado del ajuste. Al crear ejemplos sintéticos de descripciones de texto, pares de preguntas y respuestas y gráficos correspondientes, puede aumentar su conjunto de datos con ejemplos multimodales adaptados a su caso de uso específico.

El conjunto de datos que creamos consta de pares de imagen y texto, donde cada imagen es una infografía, un gráfico u otra visualización de datos. El texto correspondiente es una serie de preguntas sobre la infografía junto con respuestas reales, formateadas en un estilo de pregunta y respuesta que pretende parecerse a cómo un humano podría preguntarle al modelo sobre la información contenida en la imagen. Algunos ejemplos de preguntas generadas para imágenes como se muestra en la Figura 2 incluyen:

• ¿Cuál es el porcentaje de personas que pasan menos de 2 horas al día frente a una pantalla?
• ¿Qué proporción de personas no hacen nada de ejercicio semanalmente?
• ¿Cuántas personas son profesores?

Figura 2: Gráficos de ejemplo en el conjunto de datos de entrenamiento (a la izquierda hay un gráfico circular de distribución del tiempo de pantalla diario, a la derecha hay un gráfico de embudo de ocupación)

Estructura de datos

Estos pares de imagen y texto deben tener el formato de líneas JSON (.jsonl), donde cada línea es una muestra de entrenamiento. A continuación se muestra un ejemplo de entrenamiento. Específicamente, el identificación El campo es el identificador único de una muestra de entrenamiento, el imagen El campo especifica el nombre de la imagen y el conversaciones El campo proporciona un par de preguntas y respuestas.

{
  "id": "1",
  "image": "screen_time.png",
  "conversations": (
    {
      "from": "human",
      "value": "What is the percentage of people who spend less than 2 hours a day on screen time?"
    },
    {
      "from": "gpt",
      "value": "15%"
    }
  )
}

Al entrenar el modelo para responder preguntas analíticas y en profundidad sobre infografías que no ha visto antes, nuestro objetivo es fortalecer la capacidad del modelo para generalizar su comprensión de las visualizaciones de datos y extraer información precisa.

Ajustar el modelo

Una vez preparados los datos, los cargamos en amazon Simple Storage Service (amazon S3) como entrada de capacitación de SageMaker. Al configurar el trabajo de capacitación de SageMaker, utilizamos el TrainingInput objeto para especificar la ubicación de los datos de entrada en amazon S3 y definir cómo SageMaker debe manejarlos durante el entrenamiento. En este caso, input_mode="FastFile" indica el uso del modo de archivo rápido de S3, que es ideal para escenarios donde el conjunto de datos se almacena como archivos individuales en S3. El modo de archivo rápido de S3 también es ventajoso cuando se trabaja con grandes conjuntos de datos o cuando el acceso rápido a los datos es fundamental para el rendimiento del entrenamiento.

from sagemaker.inputs import TrainingInput

training_input = TrainingInput(
    s3_data_type="S3Prefix",  # Available Options: S3Prefix | ManifestFile | AugmentedManifestFile
    s3_data=s3uri,
    distribution="FullyReplicated",  # Available Options: FullyReplicated | ShardedByS3Key
    input_mode="FastFile",
)

Reutilizaremos el entrenamiento. guion de LLaVA, que utiliza DeepSpeed ​​para mejorar la eficiencia del entrenamiento. DeepSpeed ​​es una biblioteca que ayuda a entrenar modelos de aprendizaje profundo de gran tamaño de forma más rápida y eficiente. ZeRO, abreviatura de Zero Redundancy Optimizer, es una técnica de optimización de memoria en DeepSpeed ​​que reduce la huella de memoria requerida para el paralelismo de datos al dividir los estados y gradientes de optimización entre procesos de datos paralelos, lo que permite tamaños de modelo y lotes más grandes dentro de una memoria GPU limitada. Esto le permite entrenar modelos mucho más grandes en el mismo hardware. ZeRO Stage 2 reduce el uso de memoria al dividir el estado, los gradientes y los parámetros del optimizador del modelo en múltiples procesos. Cada proceso sólo almacena una parte de estos, reduciendo la memoria necesaria por proceso. Si se encuentra con errores de memoria CUDA con esta configuración, pruebe la configuración de la Etapa 3. La etapa 3 descarga gradientes a la CPU, lo que ralentiza el entrenamiento pero podría resolver el problema de la memoria. El comando de entrenamiento sigue. Ver el LLaVA: Asistente de Lenguaje y Visión de Gran Tamaño en GitHub para más detalles sobre los parámetros de entrenamiento

#!/bin/bash
# Set the prompt and model versions directly in the command
deepspeed /root/LLaVA/llava/train/train_mem.py \
--deepspeed /root/LLaVA/scripts/zero2.json \
--lora_enable True \
--lora_r 128 \
--lora_alpha 256 \
--mm_projector_lr 2e-5 \
--bits 4 \
--model_name_or_path /root/LLaVA/llava/llava-v1.5-7b \
--version llava_llama_2 \
--data_path /root/dataset/train/dataset.json \
--validation_data_path /root/dataset/validation/dataset.json \
--image_folder /root/dataset/images/ \
--vision_tower openai/clip-vit-large-patch14-336 \
--mm_projector_type mlp2x_gelu \
--mm_vision_select_layer -2 \
--mm_use_im_start_end False \
--mm_use_im_patch_token False \
--image_aspect_ratio pad \
--group_by_modality_length True \
--bf16 True \
--output_dir /root/LLaVA/llava/checkpoints/llama-2-7b-chat-task-qlora \
--num_train_epochs 500 \
--per_device_train_batch_size 32 \
--per_device_eval_batch_size 32 \
--gradient_accumulation_steps 1 \
--evaluation_strategy “epoch” \
--save_strategy "steps" \
--save_steps 50000 \
--save_total_limit 1 \
--learning_rate 2e-4 \
--weight_decay 0. \
--warmup_ratio 0.03 \
--lr_scheduler_type "cosine" \
--logging_steps 1 \
--tf32 True \
--model_max_length 2048 \
--gradient_checkpointing True \
--dataloader_num_workers 4 \
--lazy_preprocess True \
--report_to wandb

LLaVA le permite ajustar todos los parámetros del modelo base o usar LoRA para ajustar una cantidad menor de parámetros. La estrategia de LoRA mantiene sin cambios la columna vertebral del modelo original previamente entrenado y agrega capas nuevas y más fáciles de entrenar. Esto permite una rápida adaptación a nuevas tareas sin tener que volver a capacitar a toda la red. Puedes usar el lora_enable parámetro para especificar el método de ajuste fino. Para un ajuste completo de los parámetros, se recomienda ml.p4d.24xlarge, mientras que ml.g5.12xlarge es suficiente para un ajuste fino de LoRA si se utiliza el modelo de lenguaje LLaMA-13B.

El siguiente código inicializa un Estimador SageMaker utilizando el SDK de HuggingFace. Configura un trabajo de capacitación de SageMaker para ejecutar el script de capacitación personalizado desde LLaVA. Esto permite que el script se ejecute dentro del entorno administrado de SageMaker, beneficiándose de su escalabilidad. Luego traemos nuestro propio contenedor Docker para ejecutar el trabajo de capacitación de SageMaker. Puede descargar la imagen de Docker desde este código. amazon-sagemaker-finetune-deploy-llava-huggingface” target=”_blank” rel=”noopener”>repositoriodonde el dependencias del modelo LLaVA de formación están instalados. Para obtener más información sobre cómo adaptar su propio contenedor Docker para que funcione con SageMaker, consulte adaptación de su propio contenedor de capacitación.

huggingface_estimator = HuggingFace(
    entry_point="finetune-lora-piechart-QA.sh",
    source_dir="./LLaVA",
    instance_type=instance_type,
    instance_count=instance_count,
    py_version=PYTHON_VERSION,
    image_uri=CONTAINER_URI,
    role=ROLE,
    metric_definitions=metric_definitions,
    environment=environment,
    use_spot_instances=use_spot_instances,
    max_run=max_run,
    max_wait=max_wait,
    output_path=output_uri,
    checkpoint_s3_uri=checkpoint_uri,
)

Para fines de registro, puede utilizar definiciones de métricas para extraer métricas clave de los registros impresos del script de entrenamiento y enviarlas a amazon CloudWatch. A continuación se muestra un ejemplo de definición de métrica que registra la pérdida de entrenamiento en cada época, la tasa de aprendizaje del modelo y el rendimiento del entrenamiento.

metric_definitions = (
    {"Name": "loss", "Regex": "'loss': ((0-9)+(.|e\-)(0-9)+),?"},
    {"Name": "learning_rate", "Regex": "'learning_rate': ((0-9)+(.|e\-)(0-9)+),?"},
    {"Name": "epoch", "Regex": "'epoch': ((0-9)+(.|e\-)(0-9)+),?"},
    {"Name": "train_runtime", "Regex": "'epoch': ((0-9)+(.|e\-)(0-9)+),?"},
    {"Name": "train_samples_per_second", "Regex": "'epoch': ((0-9)+(.|e\-)(0-9)+),?"},
    {"Name": "train_steps_per_second", "Regex": "'epoch': ((0-9)+(.|e\-)(0-9)+),?"},
    {"Name": "train_loss", "Regex": "'epoch': ((0-9)+(.|e\-)(0-9)+),?"},
)

Implementar y probar

Una vez finalizado el trabajo de capacitación, el modelo ajustado se carga en amazon S3. Luego puede usar el siguiente código para implementar el modelo en SageMaker.

HF_TASK = "question-answering"
config = dict(HF_TASK=HF_TASK)
# create Hugging Face Model Class
huggingface_model = HuggingFaceModel(
    model_data=s3_model_path,
    role=get_execution_role(),
    transformers_version=TRANSFORMERS_VERSION,
    pytorch_version=PYTORCH_VERSION,
    py_version=PYTHON_VERSION,
    model_server_workers=1,
    env=config,
)

# deploy the endpoint endpoint
predictor = huggingface_model.deploy(
    initial_instance_count=instance_count, instance_type=instance_type
)

Para realizar pruebas, proporcione un par de imagen y pregunta y realice una llamada de inferencia contra el punto final de SageMaker de la siguiente manera:

prompt = "what is this chart about?"
data = {
    "image": http_img_path,
    "question": prompt,
    "temperature": 0.1,
}
output = predictor.predict(data)

Conclusión

Nuestra exploración para ajustar el modelo de lenguaje visual LLaVA en Sagemaker para una tarea de respuesta a preguntas visuales personalizada ha arrojado luz sobre los avances realizados para cerrar la brecha entre la comprensión textual y visual. LLaVA representa un importante paso adelante en la IA multimodal, demostrando la capacidad de comprender y razonar conjuntamente sobre información textual y visual en un modelo unificado. Al utilizar un entrenamiento previo a gran escala en pares de imagen y texto, LLaVA ha adquirido representaciones visiolingüísticas sólidas que pueden adaptarse de manera efectiva a tareas posteriores mediante ajustes. Esto permite a LLaVA sobresalir en tareas que requieren una comprensión profunda de ambas modalidades, como la respuesta visual a preguntas, los subtítulos de imágenes y la recuperación de información multimodal. Sin embargo, el mecanismo de ajuste tiene limitaciones. En particular, el ajuste de la capa de proyección y el modelo de lenguaje mientras se congela el modelo de visión presenta una serie de desafíos, como la necesidad de una cantidad masiva de datos y la falta de capacidad para manejar tareas de visión desafiantes. Enfrentar estos desafíos directamente nos permite desbloquear todo el potencial de los modelos multimodales, allanando el camino para aplicaciones más sofisticadas.

Reconocimiento

Los autores extienden su agradecimiento a Manoj Ravi, Jenny Vega y Santhosh Kuriakose por sus valiosos comentarios y revisión de la publicación.

Referencia

Sobre los autores

Dr. Changsha Ma es especialista en IA/ML en AWS. Es tecnóloga con un doctorado en Ciencias de la Computación, una maestría en Psicología de la Educación y años de experiencia en ciencia de datos y consultoría independiente en ai/ML. Le apasiona investigar enfoques metodológicos para la inteligencia humana y de máquinas. Fuera del trabajo, le encanta hacer senderismo, cocinar, cazar y pasar tiempo con amigos y familiares.

Jun Shi es arquitecto senior de soluciones en amazon Web Services (AWS). Sus áreas de enfoque actuales son la infraestructura y las aplicaciones de ai/ML. Tiene más de una década de experiencia en la industria FinTech como ingeniero de software.

Alfred Shen es especialista sénior en IA/ML en AWS. Ha estado trabajando en Silicon Valley, ocupando puestos técnicos y gerenciales en diversos sectores, incluidos atención médica, finanzas y alta tecnología. Es un investigador dedicado de IA/ML aplicado, que se concentra en CV, PNL y multimodalidad. Su trabajo ha aparecido en publicaciones como EMNLP, ICLR y Public Health.