Optimice el costo de implementación de los modelos básicos de Amazon SageMaker JumpStart con puntos finales asíncronos de Amazon SageMaker | Servicios web de Amazon

El éxito de las aplicaciones de IA generativa en una amplia gama de industrias ha atraído la atención y el interés de empresas de todo el mundo que buscan reproducir y superar los logros de la competencia o resolver casos de uso nuevos y apasionantes. Estos clientes están analizando modelos básicos, como TII Falcon, Stable Diffusion XL o GPT-3.5 de OpenAI, como motores que impulsan la innovación de IA generativa.

Los modelos básicos son una clase de modelos de IA generativa que son capaces de comprender y generar contenido similar al humano, gracias a las grandes cantidades de datos no estructurados con los que han sido entrenados. Estos modelos han revolucionado diversas tareas de visión por computadora (CV) y procesamiento del lenguaje natural (NLP), incluida la generación de imágenes, la traducción y la respuesta a preguntas. Sirven como base para muchas aplicaciones de IA y se han convertido en un componente crucial en el desarrollo de sistemas inteligentes avanzados.

Sin embargo, la implementación de modelos básicos puede presentar desafíos importantes, particularmente en términos de costos y requisitos de recursos. Estos modelos son conocidos por su tamaño, que a menudo oscila entre cientos de millones y miles de millones de parámetros. Su gran tamaño exige amplios recursos computacionales, incluido hardware potente y una capacidad de memoria significativa. De hecho, la implementación de modelos básicos generalmente requiere al menos una (a menudo más) GPU para manejar la carga computacional de manera eficiente. Por ejemplo, el modelo TII Falcon-40B Instruct requiere al menos una instancia ml.g5.12xlarge para cargarse correctamente en la memoria, pero funciona mejor con instancias más grandes. Como resultado, el retorno de la inversión (ROI) de implementar y mantener estos modelos puede ser demasiado bajo para demostrar el valor comercial, especialmente durante los ciclos de desarrollo o para cargas de trabajo elevadas. Esto se debe a los costos de funcionamiento que implica tener instancias con GPU para sesiones largas, potencialmente 24 horas al día, 7 días a la semana.

A principios de este año, anunciamos lecho rocoso del amazonas, una API sin servidor para acceder a modelos básicos de Amazon y nuestros socios de IA generativa. Aunque actualmente se encuentra en versión preliminar privada, su API sin servidor le permite utilizar modelos básicos de Amazon, Anthropic, Stability AI y AI21, sin tener que implementar ningún punto final usted mismo. Sin embargo, los modelos de código abierto de comunidades como Hugging Face han crecido mucho y no todos están disponibles a través de Amazon Bedrock.

En esta publicación, nos enfocamos en estas situaciones y resolvemos el problema de arriesgar altos costos mediante la implementación de grandes modelos de base para Amazon SageMaker puntos finales asincrónicos Desde JumpStart de Amazon SageMaker. Esto puede ayudar a reducir los costos de la arquitectura, permitiendo que el punto final se ejecute solo cuando las solicitudes están en la cola y por un corto tiempo de vida, mientras se reduce a cero cuando no hay solicitudes esperando ser atendidas. Esto suena genial para muchos casos de uso; sin embargo, un punto final reducido a cero introducirá un tiempo de inicio en frío antes de poder realizar inferencias.

Resumen de la solución

El siguiente diagrama ilustra la arquitectura de nuestra solución.

La arquitectura que implementamos es muy sencilla:

• La interfaz de usuario es una computadora portátil, que puede ser reemplazada por una interfaz de usuario web creada con Streamlit o tecnología similar. En nuestro caso, el cuaderno es un Estudio Amazon SageMaker notebook, ejecutándose en una instancia ml.m5.large con el kernel de CPU PyTorch 2.0 Python 3.10.
• El cuaderno consulta el punto final de tres maneras: SageMaker Python SDK, AWS SDK para Python (Boto3) y LangChain.
• El punto final se ejecuta de forma asincrónica en SageMaker y, en el punto final, implementamos el modelo Falcon-40B Instruct. Actualmente es lo último en términos de modelos de instrucción y está disponible en SageMaker JumpStart. Una única llamada API nos permite implementar el modelo en el punto final.

¿Qué es la inferencia asincrónica de SageMaker?

La inferencia asincrónica de SageMaker es una de las cuatro opciones de implementación de SageMaker, junto con los puntos finales en tiempo real, la inferencia por lotes y la inferencia sin servidor. Para obtener más información sobre las diferentes opciones de implementación, consulte Implementar modelos para inferencia.

La inferencia asincrónica de SageMaker pone en cola las solicitudes entrantes y las procesa de forma asincrónica, lo que hace que esta opción sea ideal para solicitudes con tamaños de carga grandes de hasta 1 GB, tiempos de procesamiento prolongados y requisitos de latencia casi en tiempo real. Sin embargo, la principal ventaja que proporciona cuando se trata de modelos básicos grandes, especialmente durante una prueba de concepto (POC) o durante el desarrollo, es la capacidad de configurar la inferencia asincrónica para escalar a un recuento de instancias de cero cuando no hay solicitudes para proceso, ahorrando así costes. Para obtener más información sobre la inferencia asincrónica de SageMaker, consulte inferencia asíncrona. El siguiente diagrama ilustra esta arquitectura.

Para implementar un punto final de inferencia asincrónica, debe crear un AsyncInferenceConfig objeto. si creas AsyncInferenceConfig sin especificar sus argumentos, el valor predeterminado S3OutputPath se mostrarán s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-outputs/{UNIQUE-JOB-NAME} y S3FailurePath se mostrarán s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-failures/{UNIQUE-JOB-NAME}.

¿Qué es SageMaker JumpStart?

Nuestro modelo proviene de SageMaker JumpStart, una característica de SageMaker que acelera el proceso de aprendizaje automático (ML) al ofrecer modelos previamente entrenados, plantillas de soluciones y cuadernos de ejemplo. Proporciona acceso a una amplia gama de modelos previamente entrenados para diferentes tipos de problemas, lo que le permite comenzar sus tareas de aprendizaje automático con una base sólida. SageMaker JumpStart también ofrece plantillas de soluciones para casos de uso comunes y cuadernos de ejemplo para el aprendizaje. Con SageMaker JumpStart, puede reducir el tiempo y el esfuerzo necesarios para iniciar sus proyectos de ML con lanzamientos de soluciones con un solo clic y recursos integrales para una experiencia práctica de ML.

La siguiente captura de pantalla muestra un ejemplo de algunos de los modelos disponibles en la interfaz de usuario de SageMaker JumpStart.

Implementar el modelo

Nuestro primer paso es implementar el modelo en SageMaker. Para hacer eso, podemos usar la interfaz de usuario de SageMaker JumpStart o el SDK de SageMaker Python, que proporciona una API que podemos usar para implementar el modelo en el punto final asíncrono:

%%time
from sagemaker.jumpstart.model import JumpStartModel, AsyncInferenceConfig
from sagemaker.serializers import JSONSerializer
from sagemaker.deserializers import JSONDeserializer model_id, model_version = "huggingface-llm-falcon-40b-instruct-bf16", "*"
my_model = JumpStartModel(model_id=model_id)
predictor = my_model.deploy( initial_instance_count=0, instance_type="ml.g5.12xlarge", async_inference_config=AsyncInferenceConfig()
)

Esta llamada puede tardar aproximadamente 10 minutos en completarse. Durante este tiempo, el punto final se activa, el contenedor junto con los artefactos del modelo se descargan en el punto final, la configuración del modelo se carga desde SageMaker JumpStart y luego el punto final asincrónico se expone a través de un punto final DNS. Para asegurarnos de que nuestro punto final pueda reducirse a cero, debemos configurar el escalado automático en el punto final asíncrono mediante Application Auto Scaling. Primero debe registrar su variante de punto final con Application Auto Scaling, definir una política de escalado y luego aplicar la política de escalado. En esta configuración, utilizamos una métrica personalizada usando CustomizedMetricSpecification, lo cual se conoce como ApproximateBacklogSizePerInstance, como se muestra en el siguiente código. Para obtener una lista detallada de Reloj en la nube de Amazon métricas disponibles con su punto final de inferencia asincrónica, consulte Monitoreo con CloudWatch.

import boto3 client = boto3.client("application-autoscaling")
resource_id = "endpoint/" + my_model.endpoint_name + "/variant/" + "AllTraffic" # Configure Autoscaling on asynchronous endpoint down to zero instances
response = client.register_scalable_target( ServiceNamespace="sagemaker", ResourceId=resource_id, ScalableDimension="sagemaker:variant:DesiredInstanceCount", MinCapacity=0, # Miminum number of instances we want to scale down to - scale down to 0 to stop incurring in costs MaxCapacity=1, # Maximum number of instances we want to scale up to - scale up to 1 max is good enough for dev
) response = client.put_scaling_policy( PolicyName="Invocations-ScalingPolicy", ServiceNamespace="sagemaker", # The namespace of the AWS service that provides the resource. ResourceId=resource_id, # Endpoint name ScalableDimension="sagemaker:variant:DesiredInstanceCount", # SageMaker supports only Instance Count PolicyType="TargetTrackingScaling", # 'StepScaling'|'TargetTrackingScaling' TargetTrackingScalingPolicyConfiguration={ "TargetValue": 5.0, # The target value for the metric. - here the metric is - SageMakerVariantInvocationsPerInstance "CustomizedMetricSpecification": { "MetricName": "ApproximateBacklogSizePerInstance", "Namespace": "AWS/SageMaker", "Dimensions": [{"Name": "EndpointName", "Value": my_model.endpoint_name}], "Statistic": "Average", }, "ScaleInCooldown": 600, # The amount of time, in seconds, after a scale in activity completes before another scale in activity can start. "ScaleOutCooldown": 300, # ScaleOutCooldown - The amount of time, in seconds, after a scale out activity completes before another scale out activity can start. # 'DisableScaleIn': True|False - indicates whether scale in by the target tracking policy is disabled. # If the value is true, scale in is disabled and the target tracking policy won't remove capacity from the scalable resource. },
)

Puede verificar que esta política se haya configurado correctamente navegando a la consola de SageMaker y eligiendo Endpoints bajo Inferencia en el panel de navegación y buscando el punto final que acabamos de implementar.

Invocar el punto final asíncrono

Para invocar el punto final, debe colocar la carga útil de la solicitud en Servicio de almacenamiento simple de Amazon (Amazon S3) y proporciona un puntero a esta carga útil como parte del InvokeEndpointAsync pedido. Tras la invocación, SageMaker pone en cola la solicitud para su procesamiento y devuelve un identificador y una ubicación de salida como respuesta. Tras el procesamiento, SageMaker coloca el resultado en la ubicación de Amazon S3. Opcionalmente, puede optar por recibir notificaciones de éxito o error con Servicio de notificación simple de Amazon (red social de Amazon).

SDK de SageMaker Python

Una vez completada la implementación, devolverá un AsyncPredictor objeto. Para realizar una inferencia asincrónica, debe cargar datos en Amazon S3 y utilizar el predict_async() método con el URI de S3 como entrada. Te devolverá un AsyncInferenceResponse objeto, y puede comprobar el resultado utilizando el get_response() método.

Alternativamente, si desea verificar un resultado periódicamente y devolverlo al generarlo, use el predict() método. Usamos este segundo método en el siguiente código:

import time # Invoking the asynchronous endpoint with the SageMaker Python SDK
def query_endpoint(payload): """Query endpoint and print the response""" response = predictor.predict_async( data=payload, input_path="s3://{}/{}".format(bucket, prefix), ) while True: try: response = response.get_result() break except: print("Inference is not ready ...") time.sleep(5) print(f"33[1m Input:33[0m {payload['inputs']}") print(f"33[1m Output:33[0m {response[0]['generated_text']}") query_endpoint(payload)

boto3

Exploremos ahora el invoke_endpoint_async método de Boto3 sagemaker-runtime cliente. Permite a los desarrolladores invocar de forma asincrónica un punto final de SageMaker, proporcionando un token para el seguimiento del progreso y la recuperación de la respuesta más adelante. Boto3 no ofrece una forma de esperar a que se complete la inferencia asincrónica como el SDK de SageMaker Python. get_result() operación. Por lo tanto, aprovechamos el hecho de que Boto3 almacenará la salida de inferencia en Amazon S3 en el response["OutputLocation"]. Podemos usar la siguiente función para esperar a que el archivo de inferencia se escriba en Amazon S3:

import json
import time
import boto3
from botocore.exceptions import ClientError s3_client = boto3.client("s3") # Wait until the prediction is generated
def wait_inference_file(bucket, prefix): while True: try: response = s3_client.get_object(Bucket=bucket, Key=prefix) break except ClientError as ex: if ex.response['Error']['Code'] == 'NoSuchKey': print("Waiting for file to be generated...") time.sleep(5) next else: raise except Exception as e: print(e.__dict__) raise return response

Con esta función, ahora podemos consultar el punto final:

# Invoking the asynchronous endpoint with the Boto3 SDK
import boto3 sagemaker_client = boto3.client("sagemaker-runtime") # Query the endpoint function
def query_endpoint_boto3(payload): """Query endpoint and print the response""" response = sagemaker_client.invoke_endpoint_async( EndpointName=my_model.endpoint_name, InputLocation="s3://{}/{}".format(bucket, prefix), ContentType="application/json", Accept="application/json" ) output_url = response["OutputLocation"] output_prefix = "/".join(output_url.split("/")[3:]) # Read the bytes of the file from S3 in output_url with Boto3 output = wait_inference_file(bucket, output_prefix) output = json.loads(output['Body'].read())[0]['generated_text'] # Emit output print(f"33[1m Input:33[0m {payload['inputs']}") print(f"33[1m Output:33[0m {output}") query_endpoint_boto3(payload)

LangChain

LangChain es un marco de código abierto lanzado en octubre de 2022 por Harrison Chase. Simplifica el desarrollo de aplicaciones que utilizan modelos de lenguaje grandes (LLM) al proporcionar integraciones con varios sistemas y fuentes de datos. LangChain permite el análisis de documentos, resúmenes, creación de chatbot, análisis de código y más. Ha ganado popularidad, con contribuciones de cientos de desarrolladores y una importante financiación de empresas de riesgo. LangChain permite la conexión de LLM con fuentes externas, lo que permite crear aplicaciones dinámicas que responden a datos. Ofrece bibliotecas, API y documentación para agilizar el proceso de desarrollo.

LangChain proporciona bibliotecas y ejemplos para usar puntos finales de SageMaker con su marco, lo que facilita el uso de modelos de aprendizaje automático alojados en SageMaker como el "cerebro" de la cadena. Para obtener más información sobre cómo LangChain se integra con SageMaker, consulte la Punto final de SageMaker en la documentación de LangChain.

Uno de los límites de la implementación actual de LangChain es que no admite puntos finales asincrónicos de forma nativa. Para utilizar un punto final asíncrono para LangChain, tenemos que definir una nueva clase, SagemakerAsyncEndpoint, que extiende el SagemakerEndpoint clase ya disponible en LangChain. Además, proporcionamos la siguiente información:

• El depósito de S3 y el prefijo donde la inferencia asincrónica almacenará las entradas (y salidas)
• Un número máximo de segundos para esperar antes de que se agote el tiempo
• An updated _call() función para consultar el punto final con invoke_endpoint_async() en lugar de invoke_endpoint()
• Una forma de reactivar el punto final asíncrono si está en arranque en frío (reducido a cero)

Para revisar el recién creado SagemakerAsyncEndpoint, Usted puede revisar la sagemaker_async_endpoint.py presentar disponible en GitHub.

from typing import Dict
from langchain import PromptTemplate
from langchain.llms.sagemaker_endpoint import LLMContentHandler
from langchain.chains import LLMChain
from sagemaker_async_endpoint import SagemakerAsyncEndpoint class ContentHandler(LLMContentHandler): content_type:str = "application/json" accepts:str = "application/json" len_prompt:int = 0 def transform_input(self, prompt: str, model_kwargs: Dict) -> bytes: self.len_prompt = len(prompt) input_str = json.dumps({"inputs": prompt, "parameters": {"max_new_tokens": 100, "do_sample": False, "repetition_penalty": 1.1}}) return input_str.encode('utf-8') def transform_output(self, output: bytes) -> str: response_json = output.read() res = json.loads(response_json) ans = res[0]['generated_text'] return ans chain = LLMChain( llm=SagemakerAsyncEndpoint( input_bucket=bucket, input_prefix=prefix, endpoint_name=my_model.endpoint_name, region_name=sagemaker.Session().boto_region_name, content_handler=ContentHandler(), ), prompt=PromptTemplate( input_variables=["query"], template="{query}", ),
) print(chain.run(payload['inputs']))

Limpiar

Cuando haya terminado de probar la generación de inferencias desde el punto final, recuerde eliminar el punto final para evitar incurrir en cargos adicionales:

predictor.delete_endpoint()

Conclusión

Al implementar modelos de cimientos grandes como el TII Falcon, optimizar los costos es crucial. Estos modelos requieren hardware potente y una capacidad de memoria sustancial, lo que genera altos costos de infraestructura. La inferencia asincrónica de SageMaker, una opción de implementación que procesa solicitudes de forma asincrónica, reduce los gastos al escalar el recuento de instancias a cero cuando no hay solicitudes pendientes. En esta publicación, demostramos cómo implementar grandes modelos básicos de SageMaker JumpStart en puntos finales asíncronos de SageMaker. Proporcionamos ejemplos de código utilizando SageMaker Python SDK, Boto3 y LangChain para ilustrar diferentes métodos para invocar puntos finales asincrónicos y recuperar resultados. Estas técnicas permiten a los desarrolladores e investigadores optimizar los costos mientras utilizan las capacidades de los modelos básicos para sistemas avanzados de comprensión del lenguaje.

Para obtener más información sobre la inferencia asincrónica y SageMaker JumpStart, consulte las siguientes publicaciones:

Acerca del autor.

david gallitelli es Arquitecto de Soluciones Especializado en IA/ML en la región EMEA. Tiene su sede en Bruselas y trabaja en estrecha colaboración con los clientes en todo el Benelux. Ha sido desarrollador desde que era muy joven, comenzó a programar a la edad de 7 años. Comenzó a aprender AI/ML en la universidad y se enamoró de él desde entonces.

• 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. Automoción / vehículos eléctricos, 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í.
• ChartPrime. Eleve su juego comercial con ChartPrime. Accede Aquí.
• Desplazamientos de bloque. Modernización de la propiedad de compensaciones ambientales. Accede Aquí.
• Fuente: https://aws.amazon.com/blogs/machine-learning/optimize-deployment-cost-of-amazon-sagemaker-jumpstart-foundation-models-with-amazon-sagemaker-asynchronous-endpoints/