Optimaliser distribusjonskostnadene for Amazon SageMaker JumpStart-grunnmodeller med Amazon SageMaker asynkrone endepunkter | Amazon Web Services

Suksessen til generative AI-applikasjoner på tvers av et bredt spekter av bransjer har tiltrukket seg oppmerksomhet og interesse fra selskaper over hele verden som ønsker å reprodusere og overgå prestasjonene til konkurrenter eller løse nye og spennende brukssaker. Disse kundene ser på grunnmodeller, som TII Falcon, Stable Diffusion XL eller OpenAIs GPT-3.5, som motorene som driver den generative AI-innovasjonen.

Grunnmodeller er en klasse generative AI-modeller som er i stand til å forstå og generere menneskelignende innhold, takket være de enorme mengder ustrukturerte data de har blitt trent på. Disse modellene har revolusjonert ulike datasyn (CV) og naturlig språkbehandling (NLP) oppgaver, inkludert bildegenerering, oversettelse og svar på spørsmål. De fungerer som byggeklossene for mange AI-applikasjoner og har blitt en avgjørende komponent i utviklingen av avanserte intelligente systemer.

Utplasseringen av fundamentmodeller kan imidlertid by på betydelige utfordringer, spesielt når det gjelder kostnads- og ressursbehov. Disse modellene er kjent for sin størrelse, ofte fra hundrevis av millioner til milliarder av parametere. Deres store størrelse krever omfattende beregningsressurser, inkludert kraftig maskinvare og betydelig minnekapasitet. Faktisk krever distribusjon av fundamentmodeller vanligvis minst én (ofte flere) GPUer for å håndtere beregningsbelastningen effektivt. For eksempel krever TII Falcon-40B Instruct-modellen at minst en ml.g5.12xlarge forekomst skal lastes inn i minnet på en vellykket måte, men fungerer best med større forekomster. Som et resultat av dette kan avkastningen på investeringen (ROI) av å distribuere og vedlikeholde disse modellene være for lav til å bevise forretningsverdi, spesielt under utviklingssykluser eller for høye arbeidsbelastninger. Dette skyldes driftskostnadene ved å ha GPU-drevne forekomster for lange økter, potensielt 24/7.

Tidligere i år annonserte vi Amazonas grunnfjell, et serverløst API for å få tilgang til grunnmodeller fra Amazon og våre generative AI-partnere. Selv om den for øyeblikket er i privat forhåndsvisning, lar dens serverløse APIen deg bruke grunnmodeller fra Amazon, Anthropic, Stability AI og AI21, uten å måtte distribuere noen endepunkter selv. Imidlertid har åpen kildekode-modeller fra samfunn som Hugging Face vokst mye, og ikke alle av dem har blitt gjort tilgjengelige gjennom Amazon Bedrock.

I dette innlegget målretter vi disse situasjonene og løser problemet med å risikere høye kostnader ved å distribuere store fundamentmodeller for å Amazon SageMaker asynkrone endepunkter fra Amazon SageMaker JumpStart. Dette kan bidra til å kutte kostnadene til arkitekturen, slik at endepunktet bare kjører når forespørsler er i køen og i kort tid til å leve, mens det skaleres ned til null når ingen forespørsler venter på å bli behandlet. Dette høres bra ut for mange brukstilfeller; et endepunkt som har skalert ned til null vil imidlertid introdusere en kald starttid før det kan tjene slutninger.

Løsningsoversikt

Følgende diagram illustrerer løsningsarkitekturen.

Arkitekturen vi implementerer er veldig grei:

• Brukergrensesnittet er en bærbar PC, som kan erstattes av et web-UI bygget på Streamlit eller lignende teknologi. I vårt tilfelle er notatboken en Amazon SageMaker Studio notebook, kjører på en ml.m5.large-forekomst med PyTorch 2.0 Python 3.10 CPU-kjernen.
• Notatboken spør etter endepunktet på tre måter: SageMaker Python SDK, AWS SDK for Python (Boto3) og LangChain.
• Endepunktet kjører asynkront på SageMaker, og på endepunktet distribuerer vi Falcon-40B Instruct-modellen. Det er for øyeblikket toppmoderne når det gjelder instruksjonsmodeller og tilgjengelig i SageMaker JumpStart. Et enkelt API-kall lar oss distribuere modellen på endepunktet.

Hva er SageMaker asynkron inferens

SageMaker asynkron inferens er ett av de fire distribusjonsalternativene i SageMaker, sammen med sanntidsendepunkter, batch-inferens og serverløs inferens. For å lære mer om de forskjellige distribusjonsalternativene, se Distribuer modeller for inferens.

SageMaker asynkron inferens setter innkommende forespørsler i kø og behandler dem asynkront, noe som gjør dette alternativet ideelt for forespørsler med store nyttelaststørrelser på opptil 1 GB, lange behandlingstider og krav til ventetid nesten i sanntid. Imidlertid er den største fordelen det gir når man arbeider med store fundamentmodeller, spesielt under et proof of concept (POC) eller under utvikling, muligheten til å konfigurere asynkron inferens for å skalere inn til en forekomstantall på null når det ikke er noen forespørsler om å prosess, og dermed spare kostnader. For mer informasjon om SageMaker asynkron inferens, se Asynkron slutning. Følgende diagram illustrerer denne arkitekturen.

For å distribuere et asynkront inferensendepunkt, må du opprette en AsyncInferenceConfig gjenstand. Hvis du oppretter AsyncInferenceConfig uten å spesifisere argumentene, standard S3OutputPath vil være s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-outputs/{UNIQUE-JOB-NAME} og S3FailurePath vil være s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-failures/{UNIQUE-JOB-NAME}.

Hva er SageMaker JumpStart

Modellen vår kommer fra SageMaker JumpStart, en funksjon i SageMaker som akselererer reisen med maskinlæring (ML) ved å tilby forhåndsopplærte modeller, løsningsmaler og eksempelnotatbøker. Den gir tilgang til et bredt spekter av forhåndstrente modeller for ulike problemtyper, slik at du kan starte ML-oppgavene dine med et solid grunnlag. SageMaker JumpStart tilbyr også løsningsmaler for vanlige brukstilfeller og eksempelnotatbøker for læring. Med SageMaker JumpStart kan du redusere tiden og innsatsen som kreves for å starte ML-prosjektene dine med ett-klikks-løsningslanseringer og omfattende ressurser for praktisk ML-opplevelse.

Følgende skjermbilde viser et eksempel på bare noen av modellene som er tilgjengelige på SageMaker JumpStart UI.

Distribuer modellen

Vårt første skritt er å distribuere modellen til SageMaker. For å gjøre det kan vi bruke brukergrensesnittet for SageMaker JumpStart eller SageMaker Python SDK, som gir en API som vi kan bruke til å distribuere modellen til det asynkrone endepunktet:

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

Denne samtalen kan ta omtrent 10 minutter å fullføre. I løpet av denne tiden spinnes endepunktet opp, beholderen sammen med modellartefaktene lastes ned til endepunktet, modellkonfigurasjonen lastes fra SageMaker JumpStart, deretter eksponeres det asynkrone endepunktet via et DNS-endepunkt. For å sikre at endepunktet vårt kan skaleres ned til null, må vi konfigurere automatisk skalering på det asynkrone endepunktet ved hjelp av Application Auto Scaling. Du må først registrere endepunktvarianten med Application Auto Scaling, definere en skaleringspolicy og deretter bruke skaleringspolicyen. I denne konfigurasjonen bruker vi en egendefinert beregning ved hjelp av CustomizedMetricSpecification, Kalt ApproximateBacklogSizePerInstance, som vist i følgende kode. For en detaljert liste over Amazon CloudWatch metrikk tilgjengelig med ditt asynkrone inferensendepunkt, se Overvåking 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 bekrefte at denne policyen har blitt satt ved å gå til SageMaker-konsollen og velge endepunkter etter slutning i navigasjonsruten, og leter etter endepunktet vi nettopp distribuerte.

Påkall det asynkrone endepunktet

For å påkalle endepunktet, må du plassere nyttelasten for forespørselen Amazon enkel lagringstjeneste (Amazon S3) og gi en peker til denne nyttelasten som en del av InvokeEndpointAsync be om. Ved påkalling setter SageMaker forespørselen i kø for behandling og returnerer en identifikator og utdataplassering som et svar. Ved behandling plasserer SageMaker resultatet i Amazon S3-lokasjonen. Du kan valgfritt velge å motta suksess- eller feilmeldinger med Amazon enkel varslingstjeneste (Amazon SNS).

SageMaker Python SDK

Etter at distribusjonen er fullført, vil den returnere en AsyncPredictor gjenstand. For å utføre asynkron inferens, må du laste opp data til Amazon S3 og bruke predict_async() metode med S3 URI som inngang. Det vil returnere en AsyncInferenceResponse objekt, og du kan sjekke resultatet ved å bruke get_response() metoden.

Alternativt, hvis du ønsker å sjekke et resultat med jevne mellomrom og returnere det ved generering, bruk predict() metode. Vi bruker denne andre metoden 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

La oss nå utforske invoke_endpoint_async metode fra Boto3s sagemaker-runtime klient. Det gjør det mulig for utviklere å asynkront påkalle et SageMaker-endepunkt, og gir et token for fremdriftssporing og henting av svaret senere. Boto3 tilbyr ikke en måte å vente på at den asynkrone slutningen skal fullføres som SageMaker Python SDK-ene get_result() operasjon. Derfor drar vi nytte av det faktum at Boto3 vil lagre inferensutgangen i Amazon S3 i response["OutputLocation"]. Vi kan bruke følgende funksjon for å vente på at slutningsfilen skal skrives 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 funksjonen kan vi nå spørre endepunktet:

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

Langkjede

LangChain er et åpen kildekode-rammeverk lansert i oktober 2022 av Harrison Chase. Det forenkler utviklingen av applikasjoner som bruker store språkmodeller (LLM) ved å tilby integrasjoner med ulike systemer og datakilder. LangChain tillater dokumentanalyse, oppsummering, oppretting av chatbot, kodeanalyse og mer. Det har vunnet popularitet, med bidrag fra hundrevis av utviklere og betydelig finansiering fra venturefirmaer. LangChain muliggjør tilkobling av LLM-er med eksterne kilder, noe som gjør det mulig å lage dynamiske, dataresponsive applikasjoner. Den tilbyr biblioteker, APIer og dokumentasjon for å strømlinjeforme utviklingsprosessen.

LangChain gir biblioteker og eksempler for bruk av SageMaker-endepunkter med rammeverket, noe som gjør det enklere å bruke ML-modeller som ligger på SageMaker som "hjernen" i kjeden. For å lære mer om hvordan LangChain integreres med SageMaker, se SageMaker endepunkt i LangChain-dokumentasjonen.

En av grensene for den nåværende implementeringen av LangChain er at den ikke støtter asynkrone endepunkter innfødt. For å bruke et asynkront endepunkt til LangChain, må vi definere en ny klasse, SagemakerAsyncEndpoint, som utvider SagemakerEndpoint klasse allerede tilgjengelig i LangChain. I tillegg gir vi følgende informasjon:

• S3-bøtten og prefikset der asynkron inferens vil lagre inngangene (og utgangene)
• Maksimalt antall sekunder å vente før tidsavbrudd
• An updated _call() funksjon for å spørre endepunktet med invoke_endpoint_async() istedenfor invoke_endpoint()
• En måte å vekke det asynkrone endepunktet hvis det er i kaldstart (skalert ned til null)

For å se gjennom den nyopprettede SagemakerAsyncEndpoint, kan du sjekke ut sagemaker_async_endpoint.py fil tilgjengelig 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']))

Rydd opp

Når du er ferdig med å teste genereringen av slutninger fra endepunktet, husk å slette endepunktet for å unngå å pådra deg ekstra kostnader:

predictor.delete_endpoint()

konklusjonen

Når du implementerer store fundamentmodeller som TII Falcon, er det avgjørende å optimalisere kostnadene. Disse modellene krever kraftig maskinvare og betydelig minnekapasitet, noe som fører til høye infrastrukturkostnader. SageMaker asynchronous inference, et distribusjonsalternativ som behandler forespørsler asynkront, reduserer utgiftene ved å skalere forekomsttellingen til null når det ikke er noen ventende forespørsler. I dette innlegget demonstrerte vi hvordan du distribuerer store SageMaker JumpStart-fundamentmodeller til SageMaker asynkrone endepunkter. Vi ga kodeeksempler ved å bruke SageMaker Python SDK, Boto3 og LangChain for å illustrere forskjellige metoder for å påkalle asynkrone endepunkter og hente resultater. Disse teknikkene gjør det mulig for utviklere og forskere å optimalisere kostnadene mens de bruker mulighetene til grunnmodeller for avanserte språkforståelsessystemer.

For å lære mer om asynkron inferens og SageMaker JumpStart, sjekk ut følgende innlegg:

Om forfatteren

Davide Gallitelli er en spesialistløsningsarkitekt for AI/ML i EMEA-regionen. Han er basert i Brussel og jobber tett med kunder i hele Benelux. Han har vært utvikler siden han var veldig ung, og begynte å kode i en alder av 7. Han begynte å lære AI/ML på universitetet, og har forelsket seg i det siden den gang.

• SEO-drevet innhold og PR-distribusjon. Bli forsterket i dag.
• PlatoData.Network Vertical Generative Ai. Styrk deg selv. Tilgang her.
• PlatoAiStream. Web3 Intelligence. Kunnskap forsterket. Tilgang her.
• PlatoESG. Bil / elbiler, Karbon, CleanTech, Energi, Miljø, Solenergi, Avfallshåndtering. Tilgang her.
• PlatoHelse. Bioteknologisk og klinisk etterretning. Tilgang her.
• ChartPrime. Hev handelsspillet ditt med ChartPrime. Tilgang her.
• BlockOffsets. Modernisering av eierskap for miljøkompensasjon. Tilgang her.
• kilde: https://aws.amazon.com/blogs/machine-learning/optimize-deployment-cost-of-amazon-sagemaker-jumpstart-foundation-models-with-amazon-sagemaker-asynchronous-endpoints/