Optimer implementeringsomkostningerne for Amazon SageMaker JumpStart-grundmodeller med Amazon SageMaker asynkrone slutpunkter | Amazon Web Services

Succesen med generative AI-applikationer på tværs af en bred vifte af industrier har tiltrukket sig opmærksomhed og interesse fra virksomheder verden over, som søger at reproducere og overgå konkurrenternes præstationer eller løse nye og spændende use cases. Disse kunder kigger på fundamentmodeller, såsom TII Falcon, Stable Diffusion XL eller OpenAI's GPT-3.5, som motorerne, der driver den generative AI-innovation.

Foundation-modeller er en klasse af generative AI-modeller, der er i stand til at forstå og generere menneskelignende indhold, takket være de enorme mængder af ustrukturerede data, de er blevet trænet i. Disse modeller har revolutioneret forskellige computer vision (CV) og naturlig sprogbehandling (NLP) opgaver, herunder billedgenerering, oversættelse og besvarelse af spørgsmål. De fungerer som byggestenene for mange AI-applikationer og er blevet en afgørende komponent i udviklingen af ​​avancerede intelligente systemer.

Implementeringen af ​​fundamentmodeller kan dog byde på betydelige udfordringer, især med hensyn til omkostninger og ressourcekrav. Disse modeller er kendt for deres størrelse, der ofte spænder fra hundreder af millioner til milliarder af parametre. Deres store størrelse kræver omfattende beregningsressourcer, herunder kraftfuld hardware og betydelig hukommelseskapacitet. Faktisk kræver implementering af fundamentmodeller normalt mindst én (ofte flere) GPU'er for at håndtere beregningsbelastningen effektivt. For eksempel kræver TII Falcon-40B Instruct-modellen mindst en ml.g5.12xlarge forekomst for at blive indlæst i hukommelsen med succes, men den klarer sig bedst med større forekomster. Som et resultat heraf kan investeringsafkastet (ROI) ved at implementere og vedligeholde disse modeller være for lavt til at bevise forretningsværdi, især under udviklingscyklusser eller for spidse arbejdsbelastninger. Dette skyldes de løbende omkostninger ved at have GPU-drevne instanser til lange sessioner, potentielt 24/7.

Tidligere i år annoncerede vi Amazonas grundfjeld, en serverløs API til at få adgang til fundamentmodeller fra Amazon og vores generative AI-partnere. Selvom det i øjeblikket er i Private Preview, giver dets serverløse API dig mulighed for at bruge fundamentmodeller fra Amazon, Anthropic, Stability AI og AI21 uden selv at skulle implementere nogen endepunkter. Open source-modeller fra fællesskaber som Hugging Face er dog vokset meget, og ikke alle af dem er blevet gjort tilgængelige gennem Amazon Bedrock.

I dette indlæg målretter vi disse situationer og løser problemet med at risikere høje omkostninger ved at implementere store fundamentmodeller til Amazon SageMaker asynkrone endepunkter fra Amazon SageMaker JumpStart. Dette kan hjælpe med at reducere omkostningerne til arkitekturen, så slutpunktet kun kan køre, når forespørgsler er i køen og i en kort levetid, mens det skaleres ned til nul, når ingen anmodninger venter på at blive behandlet. Dette lyder godt til mange brugssager; et endepunkt, der er nedskaleret til nul, vil dog introducere en koldstartstid, før den er i stand til at tjene slutninger.

Løsningsoversigt

Følgende diagram illustrerer vores løsningsarkitektur.

Arkitekturen vi implementerer er meget ligetil:

• Brugergrænsefladen er en notesbog, som kan erstattes af en web-UI bygget på Streamlit eller lignende teknologi. I vores tilfælde er notesbogen en Amazon SageMaker Studio notebook, der kører på en ml.m5.large instans med PyTorch 2.0 Python 3.10 CPU-kernen.
• Notebook'en forespørger slutpunktet på tre måder: SageMaker Python SDK, AWS SDK for Python (Boto3) og LangChain.
• Slutpunktet kører asynkront på SageMaker, og på slutpunktet implementerer vi Falcon-40B Instruct-modellen. Det er i øjeblikket det nyeste med hensyn til instruktionsmodeller og tilgængeligt i SageMaker JumpStart. Et enkelt API-kald giver os mulighed for at implementere modellen på slutpunktet.

Hvad er SageMaker asynkron inferens

SageMaker asynkron inferens er en af ​​de fire implementeringsmuligheder i SageMaker sammen med real-time slutpunkter, batch-inferens og serverløs inferens. For at lære mere om de forskellige implementeringsmuligheder, se Implementer modeller til inferens.

SageMaker asynkron inferens sætter indgående anmodninger i kø og behandler dem asynkront, hvilket gør denne mulighed ideel til anmodninger med store nyttelaststørrelser op til 1 GB, lange behandlingstider og krav til ventetid næsten i realtid. Den største fordel, som det giver, når det drejer sig om store fundamentmodeller, især under et proof of concept (POC) eller under udvikling, er evnen til at konfigurere asynkron inferens til at skalere ind til en instanstælling på nul, når der ikke er nogen anmodninger om proces og derved spare omkostninger. For mere information om SageMaker asynkron inferens, se Asynkron inferens. Følgende diagram illustrerer denne arkitektur.

For at implementere et asynkront inferensslutpunkt skal du oprette en AsyncInferenceConfig objekt. Hvis du opretter AsyncInferenceConfig uden at specificere dens argumenter, standard S3OutputPath vil være s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-outputs/{UNIQUE-JOB-NAME} , S3FailurePath vil være s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-failures/{UNIQUE-JOB-NAME}.

Hvad er SageMaker JumpStart

Vores model kommer fra SageMaker JumpStart, en funktion i SageMaker, der accelererer maskinlæringsrejsen (ML) ved at tilbyde forudtrænede modeller, løsningsskabeloner og eksempelnotebooks. Det giver adgang til en lang række præ-trænede modeller til forskellige problemtyper, så du kan starte dine ML-opgaver med et solidt fundament. SageMaker JumpStart tilbyder også løsningsskabeloner til almindelige use cases og eksempler på notesbøger til læring. Med SageMaker JumpStart kan du reducere den tid og indsats, der kræves for at starte dine ML-projekter med et-klik-løsningslanceringer og omfattende ressourcer til praktisk ML-oplevelse.

Følgende skærmbillede viser et eksempel på blot nogle af de modeller, der er tilgængelige på SageMaker JumpStart UI.

Implementer modellen

Vores første skridt er at implementere modellen til SageMaker. For at gøre det kan vi bruge brugergrænsefladen til SageMaker JumpStart eller SageMaker Python SDK, som giver en API, som vi kan bruge til at implementere modellen til det asynkrone slutpunkt:

%%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()
)

Dette opkald kan tage cirka 10 minutter at gennemføre. I løbet af denne tid drejes endepunktet op, containeren sammen med modelartefakterne downloades til endepunktet, modelkonfigurationen indlæses fra SageMaker JumpStart, hvorefter det asynkrone endepunkt eksponeres via et DNS-slutpunkt. For at sikre, at vores endepunkt kan skalere ned til nul, skal vi konfigurere automatisk skalering på det asynkrone endepunkt ved hjælp af Application Auto Scaling. Du skal først registrere din slutpunktsvariant med Application Auto Scaling, definere en skaleringspolitik og derefter anvende skaleringspolitikken. I denne konfiguration bruger vi en brugerdefineret metrik vha CustomizedMetricSpecification, Kaldet ApproximateBacklogSizePerInstance, som vist i følgende kode. For en detaljeret liste over amazoncloudwatch metrikker, der er tilgængelige med dit asynkrone inferensendepunkt, se Overvågning med 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. },
)

Du kan bekræfte, at denne politik er blevet indstillet korrekt ved at navigere til SageMaker-konsollen og vælge Endpoints under Inferens i navigationsruden og leder efter det endepunkt, vi lige har implementeret.

Kald det asynkrone endepunkt

For at kalde slutpunktet skal du placere anmodningens nyttelast i Amazon Simple Storage Service (Amazon S3) og giv en pegepind til denne nyttelast som en del af InvokeEndpointAsync anmodning. Ved påkaldelse sætter SageMaker anmodningen i kø for behandling og returnerer en identifikator og outputplacering som et svar. Efter behandling placerer SageMaker resultatet i Amazon S3-lokationen. Du kan valgfrit vælge at modtage succes- eller fejlmeddelelser med Amazon Simple Notification Service (Amazon SNS).

SageMaker Python SDK

Når implementeringen er fuldført, returnerer den en AsyncPredictor objekt. For at udføre asynkron inferens skal du uploade data til Amazon S3 og bruge predict_async() metode med S3 URI som input. Det vil returnere en AsyncInferenceResponse objekt, og du kan kontrollere resultatet ved hjælp af get_response() fremgangsmåde.

Alternativt, hvis du gerne vil tjekke for et resultat med jævne mellemrum og returnere det ved generering, skal du bruge predict() metode. Vi bruger denne anden metode i følgende kode:

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

Lad os nu udforske invoke_endpoint_async metode fra Boto3's sagemaker-runtime klient. Det gør det muligt for udviklere asynkront at påkalde et SageMaker-slutpunkt, hvilket giver et token til fremskridtssporing og genfinding af svaret senere. Boto3 tilbyder ikke en måde at vente på, at den asynkrone inferens bliver fuldført som SageMaker Python SDK's get_result() operation. Derfor udnytter vi det faktum, at Boto3 vil gemme inferensoutputtet i Amazon S3 i response["OutputLocation"]. Vi kan bruge følgende funktion til at vente på, at inferensfilen bliver skrevet til 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

Med denne funktion kan vi nu forespørge på slutpunktet:

# 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)

Langkæde

LangChain er en open source-ramme, der blev lanceret i oktober 2022 af Harrison Chase. Det forenkler udviklingen af ​​applikationer ved hjælp af store sprogmodeller (LLM'er) ved at tilbyde integrationer med forskellige systemer og datakilder. LangChain giver mulighed for dokumentanalyse, opsummering, oprettelse af chatbot, kodeanalyse og mere. Det har vundet popularitet med bidrag fra hundredvis af udviklere og betydelig finansiering fra venturefirmaer. LangChain muliggør forbindelse af LLM'er med eksterne kilder, hvilket gør det muligt at skabe dynamiske, data-responsive applikationer. Det tilbyder biblioteker, API'er og dokumentation for at strømline udviklingsprocessen.

LangChain leverer biblioteker og eksempler på brug af SageMaker-endepunkter med dens ramme, hvilket gør det nemmere at bruge ML-modeller hostet på SageMaker som "hjerne" i kæden. For at lære mere om, hvordan LangChain integrerer med SageMaker, henvises til SageMaker Endpoint i LangChain-dokumentationen.

En af grænserne for den nuværende implementering af LangChain er, at den ikke understøtter asynkrone endepunkter indbygget. For at bruge et asynkront endepunkt til LangChain, skal vi definere en ny klasse, SagemakerAsyncEndpoint, der udvider SagemakerEndpoint klasse allerede tilgængelig i LangChain. Derudover giver vi følgende oplysninger:

• S3-bøtten og præfikset, hvor asynkron inferens gemmer input (og output)
• Et maksimalt antal sekunder at vente før timeout
• An updated _call() funktion til at forespørge slutpunktet med invoke_endpoint_async() i stedet for invoke_endpoint()
• En måde at vække det asynkrone slutpunkt på, hvis det er i koldstart (skaleret ned til nul)

For at gennemgå den nyoprettede SagemakerAsyncEndpoint, kan du tjekke ud sagemaker_async_endpoint.py fil tilgængelig på 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']))

Ryd op

Når du er færdig med at teste genereringen af ​​slutninger fra slutpunktet, skal du huske at slette slutpunktet for at undgå at pådrage dig ekstra gebyrer:

predictor.delete_endpoint()

Konklusion

Når du implementerer store fundamentmodeller som TII Falcon, er optimering af omkostningerne afgørende. Disse modeller kræver kraftig hardware og betydelig hukommelseskapacitet, hvilket fører til høje infrastrukturomkostninger. SageMaker asynkron inferens, en implementeringsmulighed, der behandler anmodninger asynkront, reducerer omkostningerne ved at skalere instansantallet til nul, når der ikke er nogen afventende anmodninger. I dette indlæg demonstrerede vi, hvordan man implementerer store SageMaker JumpStart-fundamentmodeller til SageMaker asynkrone endepunkter. Vi leverede kodeeksempler ved hjælp af SageMaker Python SDK, Boto3 og LangChain for at illustrere forskellige metoder til at kalde asynkrone endepunkter og hente resultater. Disse teknikker gør det muligt for udviklere og forskere at optimere omkostningerne, mens de bruger mulighederne i grundmodeller til avancerede sprogforståelsessystemer.

For at lære mere om asynkron inferens og SageMaker JumpStart, tjek følgende indlæg:

Om forfatteren

Davide Gallitelli er en Specialist Solutions Architect for AI/ML i EMEA-regionen. Han er baseret i Bruxelles og arbejder tæt sammen med kunder i hele Benelux. Han har været udvikler, siden han var meget ung, og begyndte at kode i en alder af 7. Han begyndte at lære AI/ML på universitetet, og er blevet forelsket i det siden da.

• SEO Powered Content & PR Distribution. Bliv forstærket i dag.
• PlatoData.Network Vertical Generative Ai. Styrk dig selv. Adgang her.
• PlatoAiStream. Web3 intelligens. Viden forstærket. Adgang her.
• PlatoESG. Automotive/elbiler, Kulstof, CleanTech, Energi, Miljø, Solenergi, Affaldshåndtering. Adgang her.
• PlatoHealth. Bioteknologiske og kliniske forsøgs intelligens. Adgang her.
• ChartPrime. Løft dit handelsspil med ChartPrime. Adgang her.
• BlockOffsets. Modernisering af miljømæssig offset-ejerskab. Adgang her.
• Kilde: https://aws.amazon.com/blogs/machine-learning/optimize-deployment-cost-of-amazon-sagemaker-jumpstart-foundation-models-with-amazon-sagemaker-asynchronous-endpoints/