Implemente y administre fácilmente cientos de adaptadores LoRA con la inferencia multiadaptador eficiente de SageMaker

La nueva y eficiente función de inferencia de múltiples adaptadores de Amazon SageMaker Desbloquea posibilidades interesantes para los clientes mediante el uso de modelos optimizados. Esta capacidad se integra con SageMaker componentes de inferencia para permitirle implementar y administrar cientos de adaptadores de adaptación de bajo rango (LoRA) ajustados a través de las API de SageMaker. La inferencia de múltiples adaptadores maneja el registro de adaptadores ajustados con un modelo base y los carga dinámicamente desde la memoria de la GPU, la memoria de la CPU o el disco local en milisegundos, según la solicitud. Esta característica proporciona operaciones atómicas para agregar, eliminar o actualizar adaptadores individuales en las instancias en ejecución de un punto final de SageMaker sin afectar el rendimiento ni requerir una reimplementación del punto final.

La eficiencia de los adaptadores LoRA permite una amplia gama de hiperpersonalización y personalización basada en tareas que antes requerían demasiado recursos y eran demasiado costosas para ser factibles. Por ejemplo, las empresas de marketing y software como servicio (SaaS) pueden personalizar las aplicaciones de inteligencia artificial y aprendizaje automático (IA/ML) utilizando las imágenes, el estilo artístico, el estilo de comunicación y los documentos de cada uno de sus clientes para crear campañas y artefactos que los representen. De manera similar, las empresas de sectores como la atención médica o los servicios financieros pueden reutilizar un modelo base común con adaptadores basados ​​en tareas para abordar de manera eficiente una variedad de tareas de IA especializadas. Ya sea que se trate de diagnosticar afecciones médicas, evaluar solicitudes de préstamos, comprender documentos complejos o detectar fraudes financieros, simplemente puede cambiar el adaptador LoRA ajustado a la perfección para cada caso de uso en tiempo de ejecución. Esta flexibilidad y eficiencia abren nuevas oportunidades para implementar una IA potente y personalizada en toda su organización. Con esta nueva capacidad de inferencia de múltiples adaptadores eficiente, SageMaker reduce la complejidad de implementar y administrar los adaptadores que impulsan estas aplicaciones.

En esta publicación, mostramos cómo utilizar la nueva y eficiente función de inferencia de múltiples adaptadores en SageMaker.

Planteamiento del problema

Puede utilizar modelos básicos (FM) preentrenados potentes sin necesidad de crear sus propios modelos complejos desde cero. Sin embargo, estos modelos de propósito general podrían no siempre alinearse con sus necesidades específicas o sus datos únicos. Para que estos modelos funcionen para usted, puede utilizar técnicas de ajuste fino con eficiencia de parámetros (PEFT) como LoRA.

La ventaja de PEFT y LoRA es que permiten ajustar los modelos de forma rápida y rentable. Estos métodos se basan en la idea de que Sólo una pequeña parte de un gran FM necesita actualizarse para adaptarlo a nuevas tareas o dominiosAl congelar el modelo base y actualizar solo algunas capas de adaptadores adicionales, puede ajustar los modelos de manera mucho más rápida y económica, manteniendo al mismo tiempo un alto rendimiento. Esta flexibilidad significa que puede personalizar rápidamente los modelos entrenados previamente a bajo costo para cumplir con diferentes requisitos. Al realizar inferencias, los adaptadores LoRA se pueden cargar dinámicamente en tiempo de ejecución para aumentar los resultados del modelo base para obtener el mejor rendimiento. Puede crear una biblioteca de adaptadores específicos de la tarea, del cliente o del dominio que se pueden intercambiar según sea necesario para lograr la máxima eficiencia. Esto le permite crear IA adaptada exactamente a su negocio.

Si bien los adaptadores LoRA ajustados pueden abordar de manera eficaz casos de uso específicos, administrar estos adaptadores puede ser un desafío a gran escala. Puede usar bibliotecas de código abierto o el contenedor de aprendizaje profundo (DLC) de inferencia de modelos grandes (LMI) administrado por AWS para cargar y descargar dinámicamente los pesos de los adaptadores. Los métodos de implementación actuales utilizan adaptadores fijos o Servicio de almacenamiento simple de Amazon (Amazon S3) ubicaciones, lo que hace imposible realizar cambios posteriores a la implementación sin actualizar el punto final del modelo y agrega una complejidad innecesaria. Este método de implementación también hace que sea imposible recopilar métricas por adaptador, lo que dificulta la evaluación de su estado y rendimiento.

Resumen de la solución

En esta solución, mostramos cómo utilizar la inferencia de múltiples adaptadores de manera eficiente en SageMaker para alojar y administrar múltiples adaptadores LoRA con un modelo base común. El enfoque se basa en una capacidad existente de SageMaker, componentes de inferencia, donde puede tener varios contenedores o modelos en el mismo punto final y asignar una cierta cantidad de cómputo a cada contenedor. Con los componentes de inferencia, puede crear y escalar varias copias del modelo, cada una de las cuales conserva el cómputo que ha asignado. Con los componentes de inferencia, la implementación de varios modelos que tienen requisitos de hardware específicos se convierte en un proceso mucho más simple, lo que permite la escalabilidad y el alojamiento de varios FM. Un ejemplo de implementación se vería como la siguiente figura.

Esta función extiende los componentes de inferencia a un nuevo tipo de componente, los adaptadores de componentes de inferencia, que puede usar para permitir que SageMaker administre sus adaptadores LoRA individuales a escala y, al mismo tiempo, tenga un componente de inferencia común para el modelo base que está implementando. En esta publicación, mostramos cómo crear, actualizar y eliminar adaptadores de componentes de inferencia y cómo llamarlos para la inferencia. Puede visualizar esta arquitectura como la siguiente figura.

Requisitos previos

Para ejecutar los cuadernos de ejemplo, necesita una cuenta de AWS con un Gestión de identidades y accesos de AWS Rol (IAM) con permisos para administrar los recursos creados. Para obtener más detalles, consulte Cree una cuenta de AWS.

Si es la primera vez que trabaja con Estudio Amazon SageMaker, primero debe crear un Dominio de SageMakerAdemás, es posible que deba solicitar un aumento de la cuota de servicio para las instancias de alojamiento de SageMaker correspondientes. En este ejemplo, aloja el modelo base y varios adaptadores en el mismo punto de conexión de SageMaker, por lo que utilizará una instancia de alojamiento de SageMaker ml.g5.12xlarge.

En este ejemplo, aprenderá a implementar un modelo base (Meta Llama 3.1 8B Instruir) y adaptadores LoRA en un punto final en tiempo real de SageMaker mediante componentes de inferencia. Puede encontrar el cuaderno de ejemplo en Repositorio GitHub.

import sagemaker
import boto3
import json

role = sagemaker.get_execution_role() # execution role for the endpoint
sess = sagemaker.session.Session() # sagemaker session for interacting with different AWS APIs
bucket = sess.default_bucket() # bucket to house artifacts
region = sess._region_name

sm_client = boto3.client(service_name='sagemaker')
sm_rt_client = boto3.client(service_name='sagemaker-runtime')

Descargue el modelo base del centro de modelos Hugging Face. Debido a que Meta Llama 3.1 8B Instruct es un modelo restringido, necesitará un token de acceso Hugging Face y enviar una solicitud de acceso al modelo en la página del modelo. Para obtener más detalles, consulte Acceso a modelos privados/cerrados.

from huggingface_hub import snapshot_download

model_name = sagemaker.utils.name_from_base("llama-3-1-8b-instruct")

HF_TOKEN = "<<YOUR_HF_TOKEN>>"
model_id = "meta-llama/Llama-3.1-8B-Instruct"
model_id_pathsafe = model_id.replace("/","-")
local_model_path = f"./models/{model_id_pathsafe}"
s3_model_path = f"s3://{bucket}/models/{model_id_pathsafe}"

snapshot_download(repo_id=model_id, use_auth_token=HF_TOKEN, local_dir=local_model_path, allow_patterns=[".json", ".safetensors"])

Copie el artefacto de su modelo en Amazon S3 para mejorar el tiempo de carga del modelo durante la implementación:

!aws s3 cp —recursive {local_model_path} {s3_model_path}

Seleccione uno de los Imágenes de contenedores LMI disponibles Para hospedaje. La capacidad de inferencia de adaptadores eficiente está disponible en 0.31.0-lmi13.0.0 y versiones posteriores.

inference_image_uri = "763104351884.dkr.ecr.us-west-2.amazonaws.com/djl-inference:0.31.0-lmi13.0.0-cu124"

Cree un entorno de contenedor para el contenedor de alojamiento. Los parámetros del contenedor LMI se pueden encontrar en Guías del usuario del backend de LMI.

Los parametros OPTION_MAX_LORAS y OPTION_MAX_CPU_LORAS controlar cómo se mueven los adaptadores entre la GPU, la CPU y el disco. OPTION_MAX_LORAS Establece un límite en la cantidad de adaptadores almacenados simultáneamente en la memoria de la GPU, y los adaptadores sobrantes se descargan en la memoria de la CPU.  OPTION_MAX_CPU_LORAS determina cuántos adaptadores se almacenan en la memoria de la CPU y descarga los adaptadores sobrantes al almacenamiento SSD local.

En el siguiente ejemplo, 30 adaptadores pueden vivir en la memoria de la GPU y 70 adaptadores en la memoria de la CPU antes de ir al almacenamiento local.

env = {
    "HF_MODEL_ID": f"{s3_model_path}",
    "OPTION_ROLLING_BATCH": "lmi-dist",
    "OPTION_MAX_ROLLING_BATCH_SIZE": "16",
    "OPTION_TENSOR_PARALLEL_DEGREE": "max",
    "OPTION_ENABLE_LORA": "true",
    "OPTION_MAX_LORAS": "30",
    "OPTION_MAX_CPU_LORAS": "70",
    "OPTION_DTYPE": "fp16",
    "OPTION_MAX_MODEL_LEN": "6000"
}

Una vez definidos la imagen y el entorno del contenedor, puede crear un objeto de modelo de SageMaker que utilizará para crear un componente de inferencia más adelante:

model_name = sagemaker.utils.name_from_base("llama-3-1-8b-instruct")

create_model_response = sm_client.create_model(
    ModelName = model_name,
    ExecutionRoleArn = role,
    PrimaryContainer = {
        "Image": inference_image_uri,
        "Environment": env,
    },
)

Configurar un punto final de SageMaker

Para crear un punto de conexión de SageMaker, necesita una configuración de punto de conexión. Cuando se utilizan componentes de inferencia, no se especifica un modelo en la configuración del punto de conexión. Se carga el modelo como un componente más adelante.

endpoint_config_name = f"{model_name}"
variant_name = "AllTraffic"
instance_type = "ml.g5.12xlarge"
model_data_download_timeout_in_seconds = 900
container_startup_health_check_timeout_in_seconds = 900

initial_instance_count = 1

sm_client.create_endpoint_config(
    EndpointConfigName = endpoint_config_name,
    ExecutionRoleArn = role,
    ProductionVariants = [
        {
            "VariantName": variant_name,
            "InstanceType": instance_type,
            "InitialInstanceCount": initial_instance_count,
            "ModelDataDownloadTimeoutInSeconds": model_data_download_timeout_in_seconds,
            "ContainerStartupHealthCheckTimeoutInSeconds": container_startup_health_check_timeout_in_seconds,
            "RoutingConfig": {"RoutingStrategy": "LEAST_OUTSTANDING_REQUESTS"},
        }
    ]
)

Cree el punto final de SageMaker con el siguiente código:

create_endpoint_response = sm_client.create_endpoint(
    EndpointName = endpoint_name, EndpointConfigName = endpoint_config_name
)

Una vez creado el punto de conexión, puede crear el componente de inferencia para el modelo base. Este será el componente base del que dependerán los componentes del adaptador que cree más adelante.

Los parámetros notables aquí son Requisitos de recursos informáticosSe trata de una configuración a nivel de componente que determina la cantidad de recursos que necesita el componente (memoria, vCPU, aceleradores). Los adaptadores compartirán estos recursos con el componente base.

base_inference_component_name = f"base-{model_name}"

variant_name = "AllTraffic"

initial_copy_count = 1
min_memory_required_in_mb = 32000
number_of_accelerator_devices_required = 4

sm_client.create_inference_component(
    InferenceComponentName = base_inference_component_name,
    EndpointName = endpoint_name,
    VariantName = variant_name,
    Specification={
        "ModelName": model_name,
        "StartupParameters": {
            "ModelDataDownloadTimeoutInSeconds": model_data_download_timeout_in_seconds,
            "ContainerStartupHealthCheckTimeoutInSeconds": container_startup_health_check_timeout_in_seconds,
        },
        "ComputeResourceRequirements": {
            "MinMemoryRequiredInMb": min_memory_required_in_mb,
            "NumberOfAcceleratorDevicesRequired": number_of_accelerator_devices_required,
        },
    },
    RuntimeConfig={
        "CopyCount": initial_copy_count,
    },
)

 En este ejemplo, se crea un único adaptador, pero se pueden alojar hasta cientos de ellos por punto de conexión. Deberán comprimirse y cargarse en Amazon S3.

El paquete adaptador tiene los siguientes archivos en la raíz del archivo sin subcarpetas.

Para este ejemplo, se ajustó un adaptador utilizando QLoRA y Datos paralelos completamente fragmentados (FSDP) sobre la división del entrenamiento de la Conjunto de datos ECTSumEl entrenamiento tomó 21 minutos en un ml.p4d.24xlarge y costó aproximadamente $13 usando la versión actual. precios bajo demanda.

Para cada adaptador que vaya a implementar, debe especificar un InferenceComponentName, un ArtifactUrl con la ubicación S3 del archivo del adaptador y un BaseInferenceComponentName para crear la conexión entre el componente de inferencia del modelo base y los nuevos componentes de inferencia del adaptador. Repita este proceso para cada adaptador adicional.

ic_ectsum_name = f"adapter-ectsum-{base_inference_component_name}"
adapter_s3_uri = "<<S3_PATH_FOR_YOUR_ADAPTER>>

sm_client.create_inference_component(
    InferenceComponentName = adapter_ic1_name,
    EndpointName = endpoint_name,
    Specification={
        "BaseInferenceComponentName": inference_component_name,
        "Container": {
            "ArtifactUrl": adapter_s3_uri
        },
    },
)

Utilice el adaptador implementado

Primero, crea un mensaje para invocar el modelo para el resumen de ganancias, completando el texto fuente con un elemento aleatorio de la ECTSum conjunto de datos. Luego, almacena el resumen de la verdad fundamental del elemento para compararlo más tarde.

from datasets import load_dataset
dataset_name = "mrSoul7766/ECTSum"

test_dataset = load_dataset(dataset_name, trust_remote_code=True, split="test")

test_item = test_dataset.shuffle().select(range(1))

prompt =f"""
    <|begin_of_text|><|start_header_id|>system<|end_header_id|>
    You are an AI assistant trained to summarize earnings calls.
    Provide a concise summary of the call, capturing the key points and overall context.
    Focus on quarter over quarter revenue, earnings per share, changes in debt, highlighted risks, and growth opportunities.
    <|eot_id|><|start_header_id|>user<|end_header_id|>
    Summarize the following earnings call:

    {test_item["text"]}
    <|eot_id|><|start_header_id|>assistant<|end_header_id|>"""

ground_truth_response = test_item["summary"]

Para probar el modelo base, especifique el EndpointName para el punto final que creó anteriormente y el nombre del componente de inferencia base como InferenceComponentName, junto con su mensaje y otros parámetros de inferencia en el parámetro Cuerpo:

component_to_invoke = base_inference_component_name

response_model = sm_rt_client.invoke_endpoint(
    EndpointName = endpoint_name,
    InferenceComponentName = component_to_invoke,
    Body = json.dumps(
        {
            "inputs": prompt,
            "parameters": {"max_new_tokens": 100, "temperature":0.9}
        }
    ),
    ContentType = "application/json",
)

base_model_reponse = response_model["Body"].read().decode("utf8")["generated_text"]

Para invocar el adaptador, utilice el nombre del componente de inferencia del adaptador en su invoke_endpoint llamada:

component_to_invoke = adapter_ic1_name

response_model = sm_rt_client.invoke_endpoint(
    EndpointName = endpoint_name,
    InferenceComponentName = component_to_invoke,
    Body = json.dumps(
        {
            "inputs": prompt,
            "parameters": {"max_new_tokens": 100, "temperature":0.9}
        }
    ),
    ContentType = "application/json",
)

adapter_reponse = response_model["Body"].read().decode("utf8")["generated_text"]

Comparar salidas

Compare los resultados del modelo base y del adaptador con la realidad básica. Si bien el modelo base puede parecer subjetivamente mejor en esta prueba, la respuesta del adaptador en realidad es mucho más cercana a la respuesta de la realidad básica. Esto se demostrará con métricas en la siguiente sección.

Ground Truth:

q3 non-gaap earnings per share $3.71.
q3 sales rose 15.4 percent to $747 million.
bio rad laboratories - now anticipates 2021 non-gaap currency-neutral revenue growth between 12 to 13 percent.
sees 2021 estimated non-gaap operating margin of about 19.5 percent.
qtrly gaap income per share $129.96.

----------------------------------

Base Model Response:

Here is a summary of the earnings call:

**Key Points:**

* Revenue: $747 million, up 15.4% year-over-year (13.8% on a currency-neutral basis)
* Earnings per share: $129.96, up from $3 per share in Q3 2020
* Gross margin: 58.6% on a GAAP basis, 57.9% on a non-GAAP basis
* Operating income: $156.8 million, up from $109.6 million in Q3 2020
* Net income: $3.928

----------------------------------

Adapter Model Response:

                Here is a concise summary of the call:

                q3 revenue $747.6 million versus refinitiv ibes estimate of $753.9 million.
q3 earnings per share $3.71.
sees fy earnings per share $11.85 to $12.05.
sees fy 2021 non-gaap revenue growth to be 12% to 13%.
sees fy 2021 non-gaap gross margin to be 57.5% to 57.8%.
sees fy 2021 non-gaap operating margin to be 19.5%.

Para validar el verdadero rendimiento del adaptador, puede utilizar una herramienta como fmeval para ejecutar una evaluación de la precisión de resumen. Esto calculará las métricas METEOR, ROUGE y BertScore para el adaptador en comparación con el modelo base. Al hacerlo en comparación con la división de prueba de ECTSum, se obtienen los siguientes resultados.

El adaptador ajustado muestra un aumento del 59% en la puntuación METEOR, un aumento del 159% en la puntuación ROUGE y un aumento del 8.6% en BertScore.

El siguiente diagrama muestra la distribución de frecuencia de las puntuaciones para las diferentes métricas, donde el adaptador obtiene consistentemente mejores puntuaciones con mayor frecuencia en todas las métricas.

Observamos una diferencia de latencia de extremo a extremo de hasta un 10 % entre la invocación del modelo base y el adaptador en nuestras pruebas. Si el adaptador se carga desde la memoria de la CPU o el disco, se producirá un retraso de inicio en frío adicional para la primera carga a la GPU. Sin embargo, según las configuraciones del contenedor y el tipo de instancia elegido, estos valores pueden variar.

Actualizar un adaptador existente

Dado que los adaptadores se administran como componentes de inferencia, puede actualizarlos en un punto de conexión en ejecución. SageMaker se encarga de la descarga y la anulación del registro del adaptador anterior, y de la carga y el registro del nuevo adaptador en cada componente de inferencia base en todas las instancias en las que se ejecuta para este punto de conexión. Para actualizar un componente de inferencia de adaptador, utilice la API update_inference_component y proporcione el nombre del componente de inferencia existente y la ruta de Amazon S3 al nuevo archivo de adaptador comprimido.

Puede entrenar un nuevo adaptador o volver a cargar el artefacto del adaptador existente para probar esta funcionalidad.

update_inference_component_response = sm_client.update_inference_component(
    InferenceComponentName = adapter_ic1_name,
    Specification={
        "Container": {
            "ArtifactUrl": new_adapter_s3_uri
        },
    },
)

Quitar adaptadores

Si necesita eliminar un adaptador, llame a la API delete_inference_component con el nombre del componente de inferencia para eliminarlo:

sess = sagemaker.session.Session()
sess.delete_inference_component(adapter_ic1_name, wait = True)

Al eliminar el componente de inferencia del modelo base se eliminarán automáticamente el componente de inferencia base y cualquier componente de inferencia del adaptador asociado:

sess.delete_inference_component(base_inference_component_name, wait = True)

Precios

La inferencia de múltiples adaptadores de SageMaker generalmente está disponible en las regiones de AWS EE. UU. Este (Norte de Virginia, Ohio), EE. UU. Oeste (Oregón), Asia Pacífico (Yakarta, Mumbai, Seúl, Singapur, Sídney, Tokio), Canadá (Central), Europa (Frankfurt, Irlanda, Londres, Estocolmo), Medio Oriente (EAU) y Sudamérica (São Paulo), y está disponible sin costo adicional.

Conclusión

La nueva y eficiente función de inferencia de múltiples adaptadores de SageMaker abre posibilidades interesantes para los clientes con casos de uso de ajuste fino. Al permitir la carga dinámica de adaptadores LoRA ajustados, puede personalizar de manera rápida y rentable los modelos de IA según sus necesidades específicas. Esta flexibilidad abre nuevas oportunidades para implementar IA potente y personalizada en organizaciones de sectores como el marketing, la atención médica y las finanzas. La capacidad de administrar estos adaptadores a escala a través de los componentes de inferencia de SageMaker facilita la creación de soluciones de IA generativa personalizadas.

Acerca de los autores

Dmitri Soldatkin Dmitry es arquitecto sénior de soluciones de aprendizaje automático en AWS y ayuda a los clientes a diseñar y crear soluciones de IA y aprendizaje automático. El trabajo de Dmitry abarca una amplia gama de casos de uso de aprendizaje automático, con un interés principal en la IA generativa, el aprendizaje profundo y la ampliación del aprendizaje automático en toda la empresa. Ha ayudado a empresas de muchos sectores, incluidos los seguros, los servicios financieros, los servicios públicos y las telecomunicaciones. Le apasiona la innovación continua y el uso de datos para impulsar los resultados comerciales. Antes de unirse a AWS, Dmitry fue arquitecto, desarrollador y líder tecnológico en los campos de análisis de datos y aprendizaje automático en la industria de servicios financieros.

Giuseppe Zappia es un arquitecto de soluciones especialista en IA y aprendizaje automático en AWS, enfocado en ayudar a grandes empresas a diseñar e implementar soluciones de aprendizaje automático en AWS. Tiene más de 20 años de experiencia como ingeniero de software de pila completa y ha pasado los últimos 5 años en AWS enfocado en el campo del aprendizaje automático.

Ram Vegiraju es arquitecto de ML en el equipo de servicios de Amazon SageMaker. Se centra en ayudar a los clientes a crear y optimizar sus soluciones de IA/ML en Amazon SageMaker. En su tiempo libre, le encanta viajar y escribir.

• Distribución de relaciones públicas y contenido potenciado por SEO. Consiga amplificado hoy.
• PlatoData.Network Vertical Generativo Ai. Empodérate. Accede Aquí.
• PlatoAiStream. Inteligencia Web3. Conocimiento amplificado. Accede Aquí.
• PlatoESG. Carbón, tecnología limpia, Energía, Ambiente, Solar, Gestión de residuos. Accede Aquí.
• PlatoSalud. Inteligencia en Biotecnología y Ensayos Clínicos. Accede Aquí.
• Fuente: https://aws.amazon.com/blogs/machine-learning/easily-deploy-and-manage-hundreds-of-lora-adapters-with-sagemaker-efficient-multi-adapter-inference/