Optimera distributionskostnaden för Amazon SageMaker JumpStart grundmodeller med Amazon SageMaker asynkrona slutpunkter | Amazon webbtjänster

Framgången med generativa AI-applikationer inom ett brett spektrum av branscher har väckt uppmärksamhet och intresse från företag världen över som vill reproducera och överträffa konkurrenternas prestationer eller lösa nya och spännande användningsfall. Dessa kunder tittar på grundmodeller, såsom TII Falcon, Stable Diffusion XL eller OpenAI:s GPT-3.5, som motorerna som driver den generativa AI-innovationen.

Grundmodeller är en klass av generativa AI-modeller som kan förstå och generera mänskligt innehåll, tack vare de stora mängderna ostrukturerad data som de har tränats på. Dessa modeller har revolutionerat olika uppgifter med datorseende (CV) och naturligt språkbehandling (NLP), inklusive bildgenerering, översättning och frågesvar. De fungerar som byggstenar för många AI-tillämpningar och har blivit en avgörande komponent i utvecklingen av avancerade intelligenta system.

Utbyggnaden av grundmodeller kan dock innebära betydande utmaningar, särskilt när det gäller kostnads- och resurskrav. Dessa modeller är kända för sin storlek, ofta från hundratals miljoner till miljarder parametrar. Deras stora storlek kräver omfattande beräkningsresurser, inklusive kraftfull hårdvara och betydande minneskapacitet. Faktum är att distribution av grundmodeller vanligtvis kräver minst en (ofta fler) GPU:er för att hantera beräkningsbelastningen effektivt. TII Falcon-40B Instruct-modellen kräver till exempel att minst en ml.g5.12xlarge instans laddas in i minnet framgångsrikt, men fungerar bäst med större instanser. Som ett resultat kan avkastningen på investeringen (ROI) av att implementera och underhålla dessa modeller vara för låg för att bevisa affärsvärde, särskilt under utvecklingscykler eller för taggiga arbetsbelastningar. Detta beror på de löpande kostnaderna för att ha GPU-drivna instanser för långa sessioner, potentiellt 24/7.

Tidigare i år meddelade vi Amazonas berggrund, ett serverlöst API för att komma åt grundmodeller från Amazon och våra generativa AI-partners. Även om den för närvarande är i privat förhandsvisning, låter dess serverlösa API dig använda grundmodeller från Amazon, Anthropic, Stability AI och AI21, utan att behöva distribuera några slutpunkter själv. Men modeller med öppen källkod från gemenskaper som Hugging Face har vuxit mycket, och inte alla har gjorts tillgängliga via Amazon Bedrock.

I det här inlägget riktar vi oss mot dessa situationer och löser problemet med att riskera höga kostnader genom att implementera stora grundmodeller för att Amazon SageMaker asynkrona ändpunkter från Amazon SageMaker JumpStart. Detta kan hjälpa till att minska kostnaderna för arkitekturen, vilket gör att slutpunkten endast kan köras när förfrågningar finns i kön och under en kort tid att leva, samtidigt som den skalas ner till noll när inga förfrågningar väntar på att betjänas. Detta låter bra för många användningsfall; dock kommer en slutpunkt som har skalat ner till noll att introducera en kallstartstid innan den kan tjäna slutsatser.

Lösningsöversikt

Följande diagram illustrerar vår lösningsarkitektur.

Arkitekturen vi distribuerar är mycket enkel:

• Användargränssnittet är en anteckningsbok, som kan ersättas av ett webbgränssnitt byggt på Streamlit eller liknande teknologi. I vårt fall är anteckningsboken en Amazon SageMaker Studio notebook, som körs på en ml.m5.large-instans med PyTorch 2.0 Python 3.10 CPU-kärnan.
• Anteckningsboken frågar efter slutpunkten på tre sätt: SageMaker Python SDK, AWS SDK för Python (Boto3) och LangChain.
• Slutpunkten körs asynkront på SageMaker, och på slutpunkten distribuerar vi Falcon-40B Instruct-modellen. Det är för närvarande det senaste när det gäller instruktionsmodeller och tillgängligt i SageMaker JumpStart. Ett enda API-anrop tillåter oss att distribuera modellen på slutpunkten.

Vad är SageMaker asynkron slutledning

SageMaker asynkron inferens är ett av de fyra distributionsalternativen i SageMaker, tillsammans med realtidsslutpunkter, batch-inferens och serverlös slutledning. För att lära dig mer om de olika distributionsalternativen, se Distribuera modeller för inferens.

SageMaker asynkron slutledning köar inkommande förfrågningar och bearbetar dem asynkront, vilket gör det här alternativet idealiskt för förfrågningar med stora nyttolaststorlekar upp till 1 GB, långa bearbetningstider och fördröjningskrav nästan i realtid. Men den största fördelen som det ger när man hanterar stora grundmodeller, särskilt under en proof of concept (POC) eller under utveckling, är möjligheten att konfigurera asynkron slutledning för att skalas in till ett instansantal på noll när det inte finns några förfrågningar om att process, vilket sparar kostnader. För mer information om SageMaker asynkron inferens, se Asynkron slutledning. Följande diagram illustrerar denna arkitektur.

För att distribuera en asynkron slutpunkt måste du skapa en AsyncInferenceConfig objekt. Om du skapar AsyncInferenceConfig utan att ange dess argument, standard S3OutputPath kommer vara s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-outputs/{UNIQUE-JOB-NAME} och S3FailurePath kommer vara s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-failures/{UNIQUE-JOB-NAME}.

Vad är SageMaker JumpStart

Vår modell kommer från SageMaker JumpStart, en funktion i SageMaker som accelererar resan med maskininlärning (ML) genom att erbjuda förutbildade modeller, lösningsmallar och exempel på anteckningsböcker. Det ger tillgång till ett brett utbud av förutbildade modeller för olika problemtyper, vilket gör att du kan börja dina ML-uppgifter med en solid grund. SageMaker JumpStart erbjuder också lösningsmallar för vanliga användningsfall och exempel på anteckningsböcker för lärande. Med SageMaker JumpStart kan du minska tiden och ansträngningen som krävs för att starta dina ML-projekt med en-klickslösningslanseringar och omfattande resurser för praktisk ML-upplevelse.

Följande skärmdump visar ett exempel på bara några av modellerna som är tillgängliga på SageMaker JumpStart UI.

Distribuera modellen

Vårt första steg är att distribuera modellen till SageMaker. För att göra det kan vi använda UI för SageMaker JumpStart eller SageMaker Python SDK, som tillhandahåller ett API som vi kan använda för att distribuera modellen till den asynkrona slutpunkten:

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

Det här samtalet kan ta cirka 10 minuter att slutföra. Under denna tid snurras ändpunkten upp, behållaren tillsammans med modellartefakter laddas ner till ändpunkten, modellkonfigurationen laddas från SageMaker JumpStart, sedan exponeras den asynkrona ändpunkten via en DNS-slutpunkt. För att säkerställa att vår slutpunkt kan skalas ner till noll måste vi konfigurera automatisk skalning på den asynkrona slutpunkten med Application Auto Scaling. Du måste först registrera din slutpunktsvariant med Application Auto Scaling, definiera en skalningspolicy och sedan tillämpa skalningspolicyn. I den här konfigurationen använder vi ett anpassat mått med CustomizedMetricSpecification, Som kallas ApproximateBacklogSizePerInstance, som visas i följande kod. För en detaljerad lista över amazoncloudwatch mätvärden som är tillgängliga med din asynkron slutpunkt, se Övervakning 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 verifiera att denna policy har ställts in framgångsrikt genom att navigera till SageMaker-konsolen och välja endpoints under Slutledning i navigeringsfönstret och letar efter slutpunkten vi just distribuerade.

Anropa den asynkrona slutpunkten

För att anropa slutpunkten måste du placera förfrågans nyttolast i Amazon enkel lagringstjänst (Amazon S3) och ge en pekare till denna nyttolast som en del av InvokeEndpointAsync begäran. Vid anrop ställer SageMaker begäran för bearbetning och returnerar en identifierare och utdataplats som ett svar. Vid bearbetning placerar SageMaker resultatet på Amazon S3-platsen. Du kan valfritt välja att få framgångs- eller felmeddelanden med Amazon enkel meddelandetjänst (Amazon SNS).

SageMaker Python SDK

När distributionen är klar kommer den att returnera en AsyncPredictor objekt. För att utföra asynkron slutledning måste du ladda upp data till Amazon S3 och använda predict_async() metod med S3 URI som indata. Det kommer att returnera en AsyncInferenceResponse objekt, och du kan kontrollera resultatet med hjälp av get_response() metod.

Alternativt, om du vill kontrollera ett resultat med jämna mellanrum och returnera det vid generering, använd predict() metod. Vi använder denna andra metod i följande kod:

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

Låt oss nu utforska invoke_endpoint_async metod från Boto3's sagemaker-runtime klient. Det gör det möjligt för utvecklare att asynkront anropa en SageMaker-slutpunkt, vilket ger en token för framstegsspårning och hämtning av svaret senare. Boto3 erbjuder inte ett sätt att vänta på att den asynkrona slutledningen ska slutföras som SageMaker Python SDK:s get_result() drift. Därför drar vi nytta av det faktum att Boto3 kommer att lagra slutledningsutgången i Amazon S3 i response["OutputLocation"]. Vi kan använda följande funktion för att vänta på att slutledningsfilen skrivs till 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 den här funktionen kan vi nu fråga efter slutpunkten:

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

Langkedja

LangChain är ett ramverk med öppen källkod som lanserades i oktober 2022 av Harrison Chase. Det förenklar utvecklingen av applikationer som använder stora språkmodeller (LLM) genom att tillhandahålla integrationer med olika system och datakällor. LangChain möjliggör dokumentanalys, sammanfattning, skapande av chatbot, kodanalys och mer. Det har vunnit popularitet, med bidrag från hundratals utvecklare och betydande finansiering från riskföretag. LangChain möjliggör anslutning av LLM med externa källor, vilket gör det möjligt att skapa dynamiska, datakänsliga applikationer. Den erbjuder bibliotek, API:er och dokumentation för att effektivisera utvecklingsprocessen.

LangChain tillhandahåller bibliotek och exempel för användning av SageMaker-slutpunkter med dess ramverk, vilket gör det lättare att använda ML-modeller som finns på SageMaker som "hjärnan" i kedjan. För att lära dig mer om hur LangChain integreras med SageMaker, se SageMaker Endpoint i LangChain-dokumentationen.

En av begränsningarna för den nuvarande implementeringen av LangChain är att den inte stöder asynkrona slutpunkter inbyggt. För att använda en asynkron slutpunkt till LangChain måste vi definiera en ny klass, SagemakerAsyncEndpoint, som förlänger SagemakerEndpoint klass redan tillgänglig i LangChain. Dessutom tillhandahåller vi följande information:

• S3-hinken och prefixet där asynkron slutledning lagrar ingångarna (och utgångarna)
• Ett maximalt antal sekunder att vänta innan timeout går ut
• An updated _call() funktion för att fråga slutpunkten med invoke_endpoint_async() istället för invoke_endpoint()
• Ett sätt att väcka den asynkrona slutpunkten om den är i kallstart (nedskalad till noll)

För att granska det nyskapade SagemakerAsyncEndpointDu kan kolla in sagemaker_async_endpoint.py fil tillgänglig 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']))

Städa upp

När du är klar med att testa genereringen av slutsatser från slutpunkten, kom ihåg att ta bort slutpunkten för att undvika extra avgifter:

predictor.delete_endpoint()

Slutsats

När man använder stora grundmodeller som TII Falcon är det avgörande att optimera kostnaderna. Dessa modeller kräver kraftfull hårdvara och betydande minneskapacitet, vilket leder till höga infrastrukturkostnader. SageMaker asynkron inferens, ett distributionsalternativ som behandlar förfrågningar asynkront, minskar kostnaderna genom att skala instansräkningen till noll när det inte finns några väntande förfrågningar. I det här inlägget visade vi hur man distribuerar stora SageMaker JumpStart-grundmodeller till SageMaker asynkrona slutpunkter. Vi gav kodexempel med SageMaker Python SDK, Boto3 och LangChain för att illustrera olika metoder för att anropa asynkrona slutpunkter och hämta resultat. Dessa tekniker gör det möjligt för utvecklare och forskare att optimera kostnaderna samtidigt som de använder kapaciteten hos grundmodeller för avancerade språkförståelsesystem.

För att lära dig mer om asynkron inferens och SageMaker JumpStart, kolla in följande inlägg:

Om författaren

Davide Gallitelli är en specialistlösningsarkitekt för AI/ML i EMEA-regionen. Han är baserad i Bryssel och har ett nära samarbete med kunder i hela Benelux. Han har varit utvecklare sedan han var väldigt ung, började koda vid 7 års ålder. Han började lära sig AI/ML på universitetet och har blivit kär i det sedan dess.

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Fordon / elbilar, Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• ChartPrime. Höj ditt handelsspel med ChartPrime. Tillgång här.
• BlockOffsets. Modernisera miljökompensation ägande. Tillgång här.
• Källa: https://aws.amazon.com/blogs/machine-learning/optimize-deployment-cost-of-amazon-sagemaker-jumpstart-foundation-models-with-amazon-sagemaker-asynchronous-endpoints/