Otimizar o custo de implantação de modelos básicos do Amazon SageMaker JumpStart com endpoints assíncronos do Amazon SageMaker | Amazon Web Services

O sucesso das aplicações generativas de IA numa vasta gama de indústrias atraiu a atenção e o interesse de empresas em todo o mundo que procuram reproduzir e superar as conquistas dos concorrentes ou resolver novos e interessantes casos de utilização. Esses clientes estão buscando modelos básicos, como TII Falcon, Stable Diffusion XL ou GPT-3.5 da OpenAI, como motores que impulsionam a inovação generativa de IA.

Os modelos básicos são uma classe de modelos generativos de IA que são capazes de compreender e gerar conteúdo semelhante ao humano, graças às grandes quantidades de dados não estruturados nos quais foram treinados. Esses modelos revolucionaram várias tarefas de visão computacional (CV) e processamento de linguagem natural (PNL), incluindo geração de imagens, tradução e resposta a perguntas. Eles servem como blocos de construção para muitas aplicações de IA e tornaram-se um componente crucial no desenvolvimento de sistemas inteligentes avançados.

No entanto, a implantação de modelos de base pode apresentar desafios significativos, especialmente em termos de custos e requisitos de recursos. Esses modelos são conhecidos por seu tamanho, muitas vezes variando de centenas de milhões a bilhões de parâmetros. Seu grande tamanho exige extensos recursos computacionais, incluindo hardware poderoso e capacidade de memória significativa. Na verdade, a implantação de modelos básicos geralmente requer pelo menos uma (geralmente mais) GPU para lidar com a carga computacional de maneira eficiente. Por exemplo, o modelo TII Falcon-40B Instruct requer pelo menos uma instância ml.g5.12xlarge para ser carregada na memória com êxito, mas tem melhor desempenho com instâncias maiores. Como resultado, o retorno sobre o investimento (ROI) da implementação e manutenção destes modelos pode ser demasiado baixo para provar o valor do negócio, especialmente durante ciclos de desenvolvimento ou para cargas de trabalho com picos. Isso se deve aos custos operacionais de ter instâncias alimentadas por GPU para sessões longas, potencialmente 24 horas por dia, 7 dias por semana.

No início deste ano, anunciamos Rocha Amazônica, uma API sem servidor para acessar modelos básicos da Amazon e de nossos parceiros generativos de IA. Embora esteja atualmente em visualização privada, sua API sem servidor permite que você use modelos básicos da Amazon, Anthropic, Stability AI e AI21, sem ter que implantar nenhum endpoint por conta própria. No entanto, modelos de código aberto de comunidades como Hugging Face têm crescido muito, e nem todos eles foram disponibilizados através do Amazon Bedrock.

Neste post, visamos essas situações e resolvemos o problema de arriscar custos elevados, implantando grandes modelos de fundação para Amazon Sage Maker pontos de extremidade assíncronos da JumpStart do Amazon SageMaker. Isso pode ajudar a reduzir custos da arquitetura, permitindo que o endpoint seja executado somente quando as solicitações estiverem na fila e por um curto período de vida, enquanto reduz para zero quando nenhuma solicitação estiver aguardando para ser atendida. Isso parece ótimo para muitos casos de uso; no entanto, um endpoint reduzido a zero introduzirá um tempo de inicialização a frio antes de poder servir inferências.

Visão geral da solução

O diagrama a seguir ilustra nossa arquitetura de solução.

A arquitetura que implantamos é muito simples:

• A interface do usuário é um notebook, que pode ser substituído por uma interface web construída em Streamlit ou tecnologia similar. No nosso caso, o notebook é um Estúdio Amazon SageMaker notebook, rodando em uma instância ml.m5.large com o kernel de CPU PyTorch 2.0 Python 3.10.
• O notebook consulta o endpoint de três maneiras: o SageMaker Python SDK, o AWS SDK for Python (Boto3) e LangChain.
• O endpoint está sendo executado de forma assíncrona no SageMaker e, no endpoint, implantamos o modelo Falcon-40B Instruct. Atualmente é o que há de mais moderno em termos de modelos de instrução e está disponível no SageMaker JumpStart. Uma única chamada de API nos permite implantar o modelo no endpoint.

O que é inferência assíncrona do SageMaker

A inferência assíncrona do SageMaker é uma das quatro opções de implantação no SageMaker, junto com endpoints em tempo real, inferência em lote e inferência sem servidor. Para saber mais sobre as diferentes opções de implantação, consulte Implantar modelos para inferência.

A inferência assíncrona do SageMaker enfileira as solicitações recebidas e as processa de forma assíncrona, tornando essa opção ideal para solicitações com grandes tamanhos de carga útil de até 1 GB, longos tempos de processamento e requisitos de latência quase em tempo real. No entanto, a principal vantagem que ele oferece ao lidar com grandes modelos básicos, especialmente durante uma prova de conceito (POC) ou durante o desenvolvimento, é a capacidade de configurar a inferência assíncrona para escalar até uma contagem de instâncias zero quando não há solicitações para processo, economizando assim custos. Para obter mais informações sobre a inferência assíncrona do SageMaker, consulte Inferência assíncrona. O diagrama a seguir ilustra essa arquitetura.

Para implantar um endpoint de inferência assíncrona, você precisa criar um AsyncInferenceConfig objeto. Se você criar AsyncInferenceConfig sem especificar seus argumentos, o padrão S3OutputPath será s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-outputs/{UNIQUE-JOB-NAME} e S3FailurePath será s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-failures/{UNIQUE-JOB-NAME}.

O que é o SageMaker JumpStart

Nosso modelo vem do SageMaker JumpStart, um recurso do SageMaker que acelera a jornada de aprendizado de máquina (ML) oferecendo modelos pré-treinados, modelos de solução e cadernos de exemplo. Ele fornece acesso a uma ampla variedade de modelos pré-treinados para diferentes tipos de problemas, permitindo que você inicie suas tarefas de ML com uma base sólida. O SageMaker JumpStart também oferece modelos de soluções para casos de uso comuns e cadernos de exemplo para aprendizagem. Com o SageMaker JumpStart, você pode reduzir o tempo e o esforço necessários para iniciar seus projetos de ML com lançamentos de soluções com um clique e recursos abrangentes para experiência prática de ML.

A captura de tela a seguir mostra um exemplo de apenas alguns dos modelos disponíveis na IU do SageMaker JumpStart.

Implantar o modelo

Nosso primeiro passo é implantar o modelo no SageMaker. Para fazer isso, podemos usar a UI do SageMaker JumpStart ou o SageMaker Python SDK, que fornece uma API que podemos usar para implantar o modelo no endpoint assí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 chamada pode levar aproximadamente 10 minutos para ser concluída. Durante esse período, o endpoint é ativado, o contêiner junto com os artefatos do modelo são baixados para o endpoint, a configuração do modelo é carregada do SageMaker JumpStart e, em seguida, o endpoint assíncrono é exposto por meio de um endpoint DNS. Para garantir que nosso endpoint possa ser reduzido a zero, precisamos configurar o escalonamento automático no endpoint assíncrono usando o Application Auto Scaling. Você precisa primeiro registrar sua variante de endpoint no Application Auto Scaling, definir uma política de escalabilidade e, em seguida, aplicar a política de escalabilidade. Nesta configuração, usamos uma métrica personalizada usando CustomizedMetricSpecification, сhamado ApproximateBacklogSizePerInstance, conforme mostrado no código a seguir. Para uma lista detalhada de Amazon CloudWatch métricas disponíveis com seu endpoint de inferência assíncrona, consulte Monitoramento com 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. },
)

Você pode verificar se esta política foi definida com sucesso navegando até o console do SageMaker, escolhendo Pontos finais para Inferência no painel de navegação e procurando o endpoint que acabamos de implantar.

Invocar o endpoint assíncrono

Para invocar o endpoint, você precisa colocar a carga útil da solicitação em Serviço de armazenamento simples da Amazon (Amazon S3) e forneça um ponteiro para essa carga útil como parte do InvokeEndpointAsync solicitar. Após a invocação, o SageMaker coloca a solicitação na fila para processamento e retorna um identificador e um local de saída como resposta. Após o processamento, o SageMaker coloca o resultado no local do Amazon S3. Opcionalmente, você pode optar por receber notificações de sucesso ou erro com Serviço de notificação simples da Amazon (Amazônia SNS).

SDK Python do SageMaker

Após a conclusão da implantação, ele retornará um AsyncPredictor objeto. Para realizar inferência assíncrona, você precisa fazer upload de dados para o Amazon S3 e usar o predict_async() método com o URI S3 como entrada. Ele retornará um AsyncInferenceResponse objeto, e você pode verificar o resultado usando o get_response() método.

Alternativamente, se você quiser verificar um resultado periodicamente e retorná-lo após a geração, use o comando predict() método. Usamos esse segundo método no código a seguir:

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

Vamos agora explorar o invoke_endpoint_async método do Boto3 sagemaker-runtime cliente. Ele permite que os desenvolvedores invoquem de forma assíncrona um endpoint SageMaker, fornecendo um token para rastreamento de progresso e recuperação posterior da resposta. Boto3 não oferece uma maneira de esperar que a inferência assíncrona seja concluída como o SageMaker Python SDK get_result() Operação. Portanto, aproveitamos o fato de que o Boto3 armazenará a saída da inferência no Amazon S3 no response["OutputLocation"]. Podemos usar a seguinte função para aguardar a gravação do arquivo de inferência no 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

Com esta função, agora podemos consultar o endpoint:

# 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 é uma estrutura de código aberto lançada em outubro de 2022 por Harrison Chase. Ele simplifica o desenvolvimento de aplicativos usando grandes modelos de linguagem (LLMs), fornecendo integrações com vários sistemas e fontes de dados. LangChain permite análise de documentos, resumo, criação de chatbot, análise de código e muito mais. Ganhou popularidade, com contribuições de centenas de desenvolvedores e financiamento significativo de empresas de risco. LangChain permite a conexão de LLMs com fontes externas, possibilitando a criação de aplicações dinâmicas e responsivas a dados. Oferece bibliotecas, APIs e documentação para agilizar o processo de desenvolvimento.

LangChain fornece bibliotecas e exemplos para usar endpoints SageMaker com sua estrutura, facilitando o uso de modelos de ML hospedados no SageMaker como o “cérebro” da cadeia. Para saber mais sobre como o LangChain se integra ao SageMaker, consulte o Ponto final do SageMaker na documentação do LangChain.

Um dos limites da implementação atual do LangChain é que ele não oferece suporte nativo a endpoints assíncronos. Para usar um endpoint assíncrono para LangChain, temos que definir uma nova classe, SagemakerAsyncEndpoint, que amplia o SagemakerEndpoint classe já disponível no LangChain. Além disso, fornecemos as seguintes informações:

• O bucket S3 e o prefixo onde a inferência assíncrona armazenará as entradas (e saídas)
• Um número máximo de segundos para esperar antes do tempo limite
• An updated _call() função para consultar o endpoint com invoke_endpoint_async() em vez de invoke_endpoint()
• Uma maneira de ativar o endpoint assíncrono se ele estiver em inicialização a frio (reduzido para zero)

Para revisar o recém-criado SagemakerAsyncEndpoint, Você pode conferir o sagemaker_async_endpoint.py lima disponível no 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']))

limpar

Quando terminar de testar a geração de inferências do endpoint, lembre-se de excluir o endpoint para evitar incorrer em cobranças extras:

predictor.delete_endpoint()

Conclusão

Ao implantar grandes modelos básicos como o TII Falcon, a otimização de custos é crucial. Esses modelos exigem hardware poderoso e capacidade de memória substancial, gerando altos custos de infraestrutura. A inferência assíncrona do SageMaker, uma opção de implantação que processa solicitações de forma assíncrona, reduz despesas ao escalar a contagem de instâncias para zero quando não há solicitações pendentes. Nesta postagem, demonstramos como implantar grandes modelos básicos do SageMaker JumpStart em endpoints assíncronos do SageMaker. Fornecemos exemplos de código usando SageMaker Python SDK, Boto3 e LangChain para ilustrar diferentes métodos para invocar endpoints assíncronos e recuperar resultados. Essas técnicas permitem que desenvolvedores e pesquisadores otimizem custos enquanto usam os recursos de modelos básicos para sistemas avançados de compreensão de linguagem.

Para saber mais sobre inferência assíncrona e SageMaker JumpStart, confira as seguintes postagens:

Sobre o autor

Davide Gallitelli é um Arquiteto de Soluções Especialista para AI/ML na região EMEA. Ele está baseado em Bruxelas e trabalha em estreita colaboração com clientes em todo o Benelux. Ele é desenvolvedor desde muito jovem, começando a codificar aos 7 anos de idade. Ele começou a aprender IA/ML na universidade e se apaixonou por isso desde então.

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Automotivo / EVs, Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
• ChartPrime. Eleve seu jogo de negociação com ChartPrime. Acesse aqui.
• BlockOffsets. Modernizando a Propriedade de Compensação Ambiental. Acesse aqui.
• Fonte: https://aws.amazon.com/blogs/machine-learning/optimize-deployment-cost-of-amazon-sagemaker-jumpstart-foundation-models-with-amazon-sagemaker-asynchronous-endpoints/