Optimaliseer de implementatiekosten van Amazon SageMaker JumpStart-basismodellen met asynchrone eindpunten van Amazon SageMaker | Amazon-webservices

Het succes van generatieve AI-toepassingen in een breed scala van industrieën heeft de aandacht en interesse getrokken van bedrijven over de hele wereld die de prestaties van concurrenten willen reproduceren en overtreffen of nieuwe en opwindende gebruiksscenario’s willen oplossen. Deze klanten onderzoeken basismodellen, zoals TII Falcon, Stable Diffusion XL of OpenAI's GPT-3.5, als de motoren die de generatieve AI-innovatie aandrijven.

Foundation-modellen zijn een klasse generatieve AI-modellen die in staat zijn mensachtige inhoud te begrijpen en te genereren, dankzij de enorme hoeveelheden ongestructureerde gegevens waarop ze zijn getraind. Deze modellen hebben een revolutie teweeggebracht in diverse taken op het gebied van computer vision (CV) en natuurlijke taalverwerking (NLP), waaronder het genereren van afbeeldingen, vertalingen en het beantwoorden van vragen. Ze dienen als bouwstenen voor veel AI-toepassingen en zijn een cruciaal onderdeel geworden in de ontwikkeling van geavanceerde intelligente systemen.

De inzet van funderingsmodellen kan echter aanzienlijke uitdagingen met zich meebrengen, vooral wat betreft de kosten en de benodigde middelen. Deze modellen staan ​​bekend om hun omvang, vaak variërend van honderden miljoenen tot miljarden parameters. Hun grote omvang vereist uitgebreide computerbronnen, waaronder krachtige hardware en aanzienlijke geheugencapaciteit. Voor het inzetten van basismodellen zijn doorgaans minstens één (vaak meer) GPU's nodig om de rekenlast efficiënt aan te kunnen. Het TII Falcon-40B Instruct-model vereist bijvoorbeeld dat ten minste een ml.g5.12xlarge-instantie met succes in het geheugen wordt geladen, maar presteert het beste met grotere instanties. Als gevolg hiervan kan het rendement op de investering (ROI) van de implementatie en het onderhoud van deze modellen te laag zijn om de bedrijfswaarde te bewijzen, vooral tijdens ontwikkelingscycli of bij piekende werklasten. Dit komt door de lopende kosten van het hebben van GPU-aangedreven instances voor lange sessies, mogelijk 24/7.

Eerder dit jaar maakten we dit bekend Amazonebodem, een serverloze API voor toegang tot basismodellen van Amazon en onze generatieve AI-partners. Hoewel het zich momenteel in Private Preview bevindt, kunt u dankzij de serverloze API basismodellen van Amazon, Anthropic, Stability AI en AI21 gebruiken, zonder dat u zelf eindpunten hoeft te implementeren. Open-sourcemodellen van gemeenschappen zoals Hugging Face zijn echter enorm gegroeid, en niet alle modellen zijn beschikbaar gesteld via Amazon Bedrock.

In dit artikel richten we ons op deze situaties en lossen we het probleem van het riskeren van hoge kosten op door grote funderingsmodellen in te zetten Amazon Sage Maker asynchrone eindpunten oppompen van Amazon SageMaker JumpStart. Dit kan helpen de kosten van de architectuur te verlagen, waardoor het eindpunt alleen kan worden uitgevoerd als er aanvragen in de wachtrij staan ​​en voor een korte time-to-live, terwijl het kan worden teruggeschroefd naar nul als er geen aanvragen wachten om te worden afgehandeld. Dit klinkt geweldig voor veel gebruiksscenario's; Een eindpunt dat naar nul is teruggeschaald, zal echter een koude starttijd introduceren voordat er gevolgtrekkingen kunnen worden gemaakt.

Overzicht oplossingen

Het volgende diagram illustreert onze oplossingsarchitectuur.

De architectuur die wij inzetten is heel eenvoudig:

• De gebruikersinterface is een notebook, die kan worden vervangen door een webinterface die is gebouwd op Streamlit of vergelijkbare technologie. In ons geval is de notebook een Amazon SageMaker Studio notebook, draait op een ml.m5.large-instantie met de PyTorch 2.0 Python 3.10 CPU-kernel.
• De notebook bevraagt ​​het eindpunt op drie manieren: de SageMaker Python SDK, de AWS SDK voor Python (Boto3) en LangChain.
• Het eindpunt draait asynchroon op SageMaker en op het eindpunt implementeren we het Falcon-40B Instruct-model. Het is momenteel het nieuwste van het nieuwste op het gebied van instructiemodellen en beschikbaar in SageMaker JumpStart. Met één enkele API-aanroep kunnen we het model op het eindpunt implementeren.

Wat is asynchrone inferentie van SageMaker?

Asynchrone inferentie van SageMaker is een van de vier implementatieopties in SageMaker, samen met realtime eindpunten, batch-inferentie en serverloze inferentie. Voor meer informatie over de verschillende implementatieopties raadpleegt u Modellen implementeren voor inferentie.

De asynchrone inferentie van SageMaker plaatst inkomende verzoeken in de wachtrij en verwerkt deze asynchroon, waardoor deze optie ideaal is voor verzoeken met grote payloads tot 1 GB, lange verwerkingstijden en bijna realtime latentievereisten. Het belangrijkste voordeel dat het biedt bij het omgaan met grote basismodellen, vooral tijdens een proof of concept (POC) of tijdens de ontwikkeling, is echter de mogelijkheid om asynchrone inferentie te configureren om op te schalen naar een instancetelling van nul wanneer er geen verzoeken zijn om proces, waardoor kosten worden bespaard. Raadpleeg voor meer informatie over de asynchrone inferentie van SageMaker Asynchrone gevolgtrekking. Het volgende diagram illustreert deze architectuur.

Als u een asynchrone inferentie-eindpunt wilt implementeren, moet u een AsyncInferenceConfig voorwerp. Als je creëert AsyncInferenceConfig zonder de argumenten op te geven, de standaardwaarde S3OutputPath zal zijn s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-outputs/{UNIQUE-JOB-NAME} en S3FailurePath zal zijn s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-failures/{UNIQUE-JOB-NAME}.

Wat is SageMaker JumpStart

Ons model is afkomstig van SageMaker JumpStart, een functie van SageMaker die het machine learning-traject (ML) versnelt door vooraf getrainde modellen, oplossingssjablonen en voorbeeldnotebooks aan te bieden. Het biedt toegang tot een breed scala aan vooraf getrainde modellen voor verschillende probleemtypen, zodat u uw ML-taken met een solide basis kunt starten. SageMaker JumpStart biedt ook oplossingssjablonen voor veelvoorkomende gebruiksscenario's en voorbeeldnotitieboekjes om te leren. Met SageMaker JumpStart kunt u de tijd en moeite die nodig is om uw ML-projecten te starten, verminderen door oplossingslanceringen met één klik en uitgebreide bronnen voor praktische ML-ervaring.

De volgende schermafbeelding toont een voorbeeld van slechts enkele van de modellen die beschikbaar zijn in de gebruikersinterface van SageMaker JumpStart.

Implementeer het model

Onze eerste stap is het implementeren van het model in SageMaker. Om dat te doen, kunnen we de gebruikersinterface voor SageMaker JumpStart of de SageMaker Python SDK gebruiken, die een API biedt die we kunnen gebruiken om het model op het asynchrone eindpunt te implementeren:

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

Het voltooien van dit gesprek kan ongeveer 10 minuten duren. Gedurende deze tijd wordt het eindpunt opgestart, wordt de container samen met de modelartefacten gedownload naar het eindpunt, wordt de modelconfiguratie geladen vanuit SageMaker JumpStart en wordt het asynchrone eindpunt toegankelijk gemaakt via een DNS-eindpunt. Om ervoor te zorgen dat ons eindpunt kan worden teruggeschaald naar nul, moeten we automatisch schalen op het asynchrone eindpunt configureren met behulp van Application Auto Scaling. U moet eerst uw eindpuntvariant registreren bij Application Auto Scaling, een schaalbeleid definiëren en vervolgens het schaalbeleid toepassen. In deze configuratie gebruiken we een aangepaste statistiek met behulp van CustomizedMetricSpecification, Genaamd ApproximateBacklogSizePerInstance, zoals weergegeven in de volgende code. Voor een gedetailleerde lijst van Amazon Cloud Watch metrische gegevens die beschikbaar zijn bij uw asynchrone inferentie-eindpunt, raadpleegt u Bewaking met 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. },
)

U kunt verifiëren dat dit beleid met succes is ingesteld door naar de SageMaker-console te navigeren en te kiezen Eindpunten voor Gevolgtrekking in het navigatievenster en op zoek naar het eindpunt dat we zojuist hebben geïmplementeerd.

Roep het asynchrone eindpunt aan

Om het eindpunt aan te roepen, moet u de payload van het verzoek plaatsen Amazon eenvoudige opslagservice (Amazon S3) en geef een verwijzing naar deze payload als onderdeel van de InvokeEndpointAsync verzoek. Bij aanroep plaatst SageMaker het verzoek voor verwerking in de wachtrij en retourneert als antwoord een identificatie en uitvoerlocatie. Na verwerking plaatst SageMaker het resultaat op de Amazon S3-locatie. U kunt er optioneel voor kiezen om succes- of foutmeldingen te ontvangen Amazon eenvoudige meldingsservice (Amazone SNS).

SageMaker Python-SDK

Nadat de implementatie is voltooid, retourneert het een AsyncPredictor voorwerp. Om asynchrone gevolgtrekking uit te voeren, moet u gegevens uploaden naar Amazon S3 en de predict_async() methode met de S3 URI als invoer. Het zal een retour sturen AsyncInferenceResponse object, en u kunt het resultaat controleren met behulp van de get_response() methode.

Als alternatief kunt u, als u periodiek wilt controleren op een resultaat en dit bij het genereren wilt retourneren, de predict() methode. We gebruiken deze tweede methode in de volgende code:

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

Laten we nu de invoke_endpoint_async methode van Boto3's sagemaker-runtime cliënt. Het stelt ontwikkelaars in staat asynchroon een SageMaker-eindpunt aan te roepen, waardoor een token wordt geboden voor het volgen van de voortgang en het later ophalen van het antwoord. Boto3 biedt geen manier om te wachten tot de asynchrone gevolgtrekking is voltooid, zoals de SageMaker Python SDK's get_result() operatie. Daarom profiteren we van het feit dat Boto3 de gevolgtrekkingsuitvoer in Amazon S3 opslaat in de response["OutputLocation"]. We kunnen de volgende functie gebruiken om te wachten tot het gevolgtrekkingsbestand naar Amazon S3 is geschreven:

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

Met deze functie kunnen we nu het eindpunt opvragen:

# 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 is een open-sourceframework dat in oktober 2022 werd gelanceerd door Harrison Chase. Het vereenvoudigt de ontwikkeling van applicaties met behulp van grote taalmodellen (LLM's) door integraties te bieden met verschillende systemen en gegevensbronnen. LangChain maakt documentanalyse, samenvatting, chatbotcreatie, codeanalyse en meer mogelijk. Het is populair geworden, met bijdragen van honderden ontwikkelaars en aanzienlijke financiering van durfondernemingen. LangChain maakt de verbinding van LLM's met externe bronnen mogelijk, waardoor het mogelijk wordt om dynamische, data-responsieve applicaties te creëren. Het biedt bibliotheken, API's en documentatie om het ontwikkelingsproces te stroomlijnen.

LangChain biedt bibliotheken en voorbeelden voor het gebruik van SageMaker-eindpunten met zijn raamwerk, waardoor het eenvoudiger wordt om ML-modellen die op SageMaker worden gehost als het ‘brein’ van de keten te gebruiken. Voor meer informatie over hoe LangChain integreert met SageMaker, raadpleegt u de SageMaker-eindpunt in de LangChain-documentatie.

Een van de beperkingen van de huidige implementatie van LangChain is dat het geen native ondersteuning biedt voor asynchrone eindpunten. Om een ​​asynchroon eindpunt voor LangChain te gebruiken, moeten we een nieuwe klasse definiëren, SagemakerAsyncEndpoint, dat verlengt de SagemakerEndpoint klasse al beschikbaar in LangChain. Daarnaast verstrekken wij de volgende informatie:

• De S3-bucket en het voorvoegsel waar asynchrone inferentie de invoer (en uitvoer) opslaat
• Een maximaal aantal seconden dat moet worden gewacht voordat er een time-out optreedt
• An updated _call() functie om het eindpunt op te vragen invoke_endpoint_async() in plaats van invoke_endpoint()
• Een manier om het asynchrone eindpunt wakker te maken als het zich in een koude start bevindt (teruggeschaald naar nul)

Om de nieuw gemaakte te bekijken SagemakerAsyncEndpoint, Kunt u kijken op de sagemaker_async_endpoint.py filet beschikbaar op 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']))

Opruimen

Wanneer u klaar bent met het testen van het genereren van gevolgtrekkingen vanaf het eindpunt, vergeet dan niet om het eindpunt te verwijderen om te voorkomen dat er extra kosten in rekening worden gebracht:

predictor.delete_endpoint()

Conclusie

Bij de inzet van grote funderingsmodellen zoals TII Falcon is het optimaliseren van de kosten cruciaal. Deze modellen vereisen krachtige hardware en een aanzienlijke geheugencapaciteit, wat leidt tot hoge infrastructuurkosten. SageMaker asynchrone inferentie, een implementatieoptie die verzoeken asynchroon verwerkt, verlaagt de kosten door het aantal instanties naar nul te schalen wanneer er geen verzoeken in behandeling zijn. In dit bericht hebben we gedemonstreerd hoe u grote SageMaker JumpStart-basismodellen kunt implementeren op asynchrone SageMaker-eindpunten. We hebben codevoorbeelden gegeven met behulp van de SageMaker Python SDK, Boto3 en LangChain om verschillende methoden te illustreren voor het aanroepen van asynchrone eindpunten en het ophalen van resultaten. Deze technieken stellen ontwikkelaars en onderzoekers in staat de kosten te optimaliseren en tegelijkertijd gebruik te maken van de mogelijkheden van basismodellen voor geavanceerde taalbegripsystemen.

Bekijk de volgende berichten voor meer informatie over asynchrone inferentie en SageMaker JumpStart:

Over de auteur

David Gallitelli is Specialist Solutions Architect voor AI/ML in de EMEA-regio. Hij is gevestigd in Brussel en werkt nauw samen met klanten in de hele Benelux. Hij is een ontwikkelaar sinds hij heel jong was en begon te coderen op 7-jarige leeftijd. Hij begon AI/ML te leren op de universiteit en is er sindsdien verliefd op geworden.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. Automotive / EV's, carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• ChartPrime. Verhoog uw handelsspel met ChartPrime. Toegang hier.
• BlockOffsets. Eigendom voor milieucompensatie moderniseren. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/optimize-deployment-cost-of-amazon-sagemaker-jumpstart-foundation-models-with-amazon-sagemaker-asynchronous-endpoints/