Optimieren Sie die Bereitstellungskosten von Amazon SageMaker JumpStart-Grundmodellen mit asynchronen Amazon SageMaker-Endpunkten | Amazon Web Services

Der Erfolg generativer KI-Anwendungen in einer Vielzahl von Branchen hat die Aufmerksamkeit und das Interesse von Unternehmen auf der ganzen Welt geweckt, die die Errungenschaften der Wettbewerber reproduzieren und übertreffen oder neue und spannende Anwendungsfälle lösen möchten. Diese Kunden suchen nach Basismodellen wie TII Falcon, Stable Diffusion XL oder GPT-3.5 von OpenAI als Motoren, die die generative KI-Innovation vorantreiben.

Foundation-Modelle sind eine Klasse generativer KI-Modelle, die dank der riesigen Mengen unstrukturierter Daten, auf denen sie trainiert wurden, in der Lage sind, menschenähnliche Inhalte zu verstehen und zu generieren. Diese Modelle haben verschiedene Aufgaben im Bereich Computer Vision (CV) und Verarbeitung natürlicher Sprache (NLP) revolutioniert, darunter Bilderzeugung, Übersetzung und Beantwortung von Fragen. Sie dienen als Bausteine ​​für viele KI-Anwendungen und sind zu einem entscheidenden Bestandteil bei der Entwicklung fortschrittlicher intelligenter Systeme geworden.

Der Einsatz von Stiftungsmodellen kann jedoch mit erheblichen Herausforderungen verbunden sein, insbesondere im Hinblick auf Kosten und Ressourcenbedarf. Diese Modelle sind für ihre Größe bekannt, die oft zwischen Hunderten Millionen und Milliarden Parametern liegt. Ihre Größe erfordert umfangreiche Rechenressourcen, einschließlich leistungsstarker Hardware und erheblicher Speicherkapazität. Tatsächlich erfordert die Bereitstellung von Basismodellen in der Regel mindestens eine (häufig mehrere) GPUs, um die Rechenlast effizient zu bewältigen. Beispielsweise erfordert das TII Falcon-40B Instruct-Modell mindestens eine ml.g5.12xlarge-Instanz, um erfolgreich in den Speicher geladen zu werden, erzielt jedoch die beste Leistung mit größeren Instanzen. Infolgedessen kann der Return on Investment (ROI) der Bereitstellung und Wartung dieser Modelle zu niedrig sein, um einen geschäftlichen Nutzen zu beweisen, insbesondere während Entwicklungszyklen oder bei Spitzenlasten. Dies ist auf die laufenden Kosten zurückzuführen, die durch GPU-betriebene Instanzen für lange Sitzungen, möglicherweise rund um die Uhr, entstehen.

Anfang dieses Jahres haben wir es angekündigt Amazonas Grundgestein, eine serverlose API für den Zugriff auf Basismodelle von Amazon und unseren generativen KI-Partnern. Obwohl es sich derzeit in der privaten Vorschau befindet, können Sie mit seiner serverlosen API Basismodelle von Amazon, Anthropic, Stability AI und AI21 verwenden, ohne selbst Endpunkte bereitstellen zu müssen. Allerdings haben Open-Source-Modelle von Communities wie Hugging Face stark zugenommen, und nicht jedes davon wurde über Amazon Bedrock verfügbar gemacht.

In diesem Beitrag gehen wir auf diese Situationen ein und lösen das Problem des Risikos hoher Kosten durch den Einsatz großer Fundamentmodelle Amazon Sage Maker asynchrone Endpunkte für Amazon SageMaker-JumpStart. Dies kann dazu beitragen, die Kosten der Architektur zu senken, da der Endpunkt nur dann ausgeführt werden kann, wenn sich Anforderungen in der Warteschlange befinden, und dies nur für eine kurze Lebensdauer, während er auf Null herunterskaliert wird, wenn keine Anforderungen auf die Bearbeitung warten. Das klingt für viele Anwendungsfälle großartig; Ein Endpunkt, der auf Null herunterskaliert wurde, führt jedoch zu einer Kaltstartzeit, bevor er Schlussfolgerungen liefern kann.

Lösungsüberblick

Das folgende Diagramm zeigt unsere Lösungsarchitektur.

Die von uns bereitgestellte Architektur ist sehr einfach:

• Die Benutzeroberfläche ist ein Notebook, das durch eine Web-Benutzeroberfläche ersetzt werden kann, die auf Streamlit oder einer ähnlichen Technologie basiert. In unserem Fall ist das Notebook ein Amazon SageMaker-Studio Notebook, läuft auf einer ml.m5.large-Instanz mit dem PyTorch 2.0 Python 3.10 CPU-Kernel.
• Das Notebook fragt den Endpunkt auf drei Arten ab: das SageMaker Python SDK, das AWS SDK for Python (Boto3) und LangChain.
• Der Endpunkt läuft asynchron auf SageMaker und auf dem Endpunkt stellen wir das Falcon-40B Instruct-Modell bereit. Es entspricht derzeit dem neuesten Stand der Technik in Bezug auf Instruct-Modelle und ist in SageMaker JumpStart verfügbar. Mit einem einzigen API-Aufruf können wir das Modell auf dem Endpunkt bereitstellen.

Was ist die asynchrone Inferenz von SageMaker?

Die asynchrone SageMaker-Inferenz ist neben Echtzeit-Endpunkten, Batch-Inferenz und serverloser Inferenz eine der vier Bereitstellungsoptionen in SageMaker. Weitere Informationen zu den verschiedenen Bereitstellungsoptionen finden Sie unter Stellen Sie Modelle für Inferenz bereit.

Die asynchrone Inferenz von SageMaker stellt eingehende Anfragen in die Warteschlange und verarbeitet sie asynchron. Dadurch eignet sich diese Option ideal für Anfragen mit großen Nutzlastgrößen von bis zu 1 GB, langen Verarbeitungszeiten und Latenzanforderungen nahezu in Echtzeit. Der Hauptvorteil, den es jedoch beim Umgang mit großen Basismodellen bietet, insbesondere während eines Proof of Concept (POC) oder während der Entwicklung, ist die Möglichkeit, asynchrone Inferenz so zu konfigurieren, dass sie auf eine Instanzanzahl von Null skaliert wird, wenn keine Anfragen dazu vorliegen Prozess und spart dadurch Kosten. Weitere Informationen zur asynchronen SageMaker-Inferenz finden Sie unter Asynchrone Inferenz. Das folgende Diagramm veranschaulicht diese Architektur.

Um einen asynchronen Inferenzendpunkt bereitzustellen, müssen Sie einen erstellen AsyncInferenceConfig Objekt. Wenn Sie erstellen AsyncInferenceConfig ohne Angabe seiner Argumente die Standardeinstellung S3OutputPath wird sein s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-outputs/{UNIQUE-JOB-NAME} und S3FailurePath wird sein s3://sagemaker-{REGION}-{ACCOUNTID}/async-endpoint-failures/{UNIQUE-JOB-NAME}.

Was ist SageMaker JumpStart?

Unser Modell stammt von SageMaker JumpStart, einer Funktion von SageMaker, die den Weg des maschinellen Lernens (ML) beschleunigt, indem sie vorab trainierte Modelle, Lösungsvorlagen und Beispielnotizbücher anbietet. Es bietet Zugriff auf eine breite Palette vorab trainierter Modelle für verschiedene Problemtypen, sodass Sie Ihre ML-Aufgaben auf einer soliden Grundlage beginnen können. SageMaker JumpStart bietet außerdem Lösungsvorlagen für gängige Anwendungsfälle und Beispielnotizbücher zum Lernen. Mit SageMaker JumpStart können Sie den Zeit- und Arbeitsaufwand für den Start Ihrer ML-Projekte durch Lösungseinführungen mit nur einem Klick und umfassende Ressourcen für praktische ML-Erfahrung reduzieren.

Der folgende Screenshot zeigt ein Beispiel einiger der Modelle, die auf der SageMaker JumpStart-Benutzeroberfläche verfügbar sind.

Stellen Sie das Modell bereit

Unser erster Schritt besteht darin, das Modell in SageMaker bereitzustellen. Dazu können wir die Benutzeroberfläche für SageMaker JumpStart oder das SageMaker Python SDK verwenden, das eine API bereitstellt, mit der wir das Modell auf dem asynchronen Endpunkt bereitstellen können:

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

Dieser Anruf kann etwa 10 Minuten dauern. Während dieser Zeit wird der Endpunkt hochgefahren, der Container wird zusammen mit den Modellartefakten auf den Endpunkt heruntergeladen, die Modellkonfiguration wird von SageMaker JumpStart geladen und dann wird der asynchrone Endpunkt über einen DNS-Endpunkt verfügbar gemacht. Um sicherzustellen, dass unser Endpunkt auf Null herunterskaliert werden kann, müssen wir die automatische Skalierung auf dem asynchronen Endpunkt mithilfe von Application Auto Scaling konfigurieren. Sie müssen zunächst Ihre Endpunktvariante bei Application Auto Scaling registrieren, eine Skalierungsrichtlinie definieren und dann die Skalierungsrichtlinie anwenden. In dieser Konfiguration verwenden wir eine benutzerdefinierte Metrik mit CustomizedMetricSpecification, Rief ApproximateBacklogSizePerInstance, wie im folgenden Code gezeigt. Für eine detaillierte Liste von Amazon CloudWatch Die mit Ihrem asynchronen Inferenzendpunkt verfügbaren Metriken finden Sie unter Überwachung mit 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. },
)

Sie können überprüfen, ob diese Richtlinie erfolgreich festgelegt wurde, indem Sie zur SageMaker-Konsole navigieren und „ Endpunkte für Inferenz im Navigationsbereich und suchen Sie nach dem Endpunkt, den wir gerade bereitgestellt haben.

Rufen Sie den asynchronen Endpunkt auf

Um den Endpunkt aufzurufen, müssen Sie die Anforderungsnutzlast darin platzieren Amazon Simple Storage-Service (Amazon S3) und stellen Sie als Teil des einen Zeiger auf diese Nutzlast bereit InvokeEndpointAsync Anfrage. Beim Aufruf stellt SageMaker die Anfrage zur Verarbeitung in die Warteschlange und gibt als Antwort eine Kennung und einen Ausgabeort zurück. Bei der Verarbeitung platziert SageMaker das Ergebnis am Amazon S3-Speicherort. Sie können optional auswählen, ob Sie Erfolgs- oder Fehlerbenachrichtigungen erhalten möchten Amazon Simple Notification Service (Amazon SNS).

SageMaker Python-SDK

Nach Abschluss der Bereitstellung wird eine zurückgegeben AsyncPredictor Objekt. Um eine asynchrone Inferenz durchzuführen, müssen Sie Daten auf Amazon S3 hochladen und verwenden predict_async() Methode mit dem S3-URI als Eingabe. Es wird ein zurückgegeben AsyncInferenceResponse Objekt, und Sie können das Ergebnis mit dem überprüfen get_response() Methode.

Wenn Sie alternativ regelmäßig nach einem Ergebnis suchen und es bei der Generierung zurückgeben möchten, verwenden Sie die predict() Methode. Wir verwenden diese zweite Methode im folgenden 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

Lassen Sie uns nun das erkunden invoke_endpoint_async Methode von Boto3 sagemaker-runtime Klient. Es ermöglicht Entwicklern, einen SageMaker-Endpunkt asynchron aufzurufen und ein Token für die Fortschrittsverfolgung und den späteren Abruf der Antwort bereitzustellen. Boto3 bietet keine Möglichkeit, wie das SageMaker Python SDK auf den Abschluss der asynchronen Inferenz zu warten get_result() Betrieb. Daher machen wir uns die Tatsache zunutze, dass Boto3 die Inferenzausgabe in Amazon S3 im speichert response["OutputLocation"]. Wir können die folgende Funktion verwenden, um darauf zu warten, dass die Inferenzdatei in Amazon S3 geschrieben wird:

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

Mit dieser Funktion können wir nun den Endpunkt abfragen:

# 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 ist ein Open-Source-Framework, das im Oktober 2022 von Harrison Chase eingeführt wurde. Es vereinfacht die Entwicklung von Anwendungen mithilfe großer Sprachmodelle (LLMs), indem es Integrationen mit verschiedenen Systemen und Datenquellen ermöglicht. LangChain ermöglicht Dokumentenanalyse, Zusammenfassung, Chatbot-Erstellung, Code-Analyse und mehr. Dank der Beiträge von Hunderten von Entwicklern und erheblicher Finanzierung durch Risikokapitalfirmen erfreut es sich immer größerer Beliebtheit. LangChain ermöglicht die Verbindung von LLMs mit externen Quellen und ermöglicht so die Erstellung dynamischer, datenresponsiver Anwendungen. Es bietet Bibliotheken, APIs und Dokumentation, um den Entwicklungsprozess zu optimieren.

LangChain stellt mit seinem Framework Bibliotheken und Beispiele für die Verwendung von SageMaker-Endpunkten bereit, wodurch es einfacher wird, auf SageMaker gehostete ML-Modelle als „Gehirn“ der Kette zu verwenden. Weitere Informationen zur Integration von LangChain in SageMaker finden Sie im SageMaker-Endpunkt in der LangChain-Dokumentation.

Eine der Einschränkungen der aktuellen Implementierung von LangChain besteht darin, dass asynchrone Endpunkte nicht nativ unterstützt werden. Um einen asynchronen Endpunkt für LangChain zu verwenden, müssen wir eine neue Klasse definieren, SagemakerAsyncEndpoint, das erweitert die SagemakerEndpoint Klasse, die bereits in LangChain verfügbar ist. Darüber hinaus stellen wir Ihnen folgende Informationen zur Verfügung:

• Der S3-Bucket und das Präfix, in dem die asynchrone Inferenz die Eingaben (und Ausgaben) speichert.
• Eine maximale Anzahl von Sekunden, die vor einer Zeitüberschreitung gewartet werden soll
• An updated _call() Funktion zum Abfragen des Endpunkts invoke_endpoint_async() statt invoke_endpoint()
• Eine Möglichkeit, den asynchronen Endpunkt aufzuwecken, wenn er sich im Kaltstart befindet (auf Null herunterskaliert)

Um das neu erstellte zu überprüfen SagemakerAsyncEndpointKönnen Sie bitte zuerst die sagemaker_async_endpoint.py Datei verfügbar auf 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']))

Aufräumen

Wenn Sie mit dem Testen der Generierung von Schlussfolgerungen vom Endpunkt fertig sind, denken Sie daran, den Endpunkt zu löschen, um zusätzliche Kosten zu vermeiden:

predictor.delete_endpoint()

Zusammenfassung

Beim Einsatz großer Fundamentmodelle wie TII Falcon ist die Kostenoptimierung von entscheidender Bedeutung. Diese Modelle erfordern leistungsstarke Hardware und erhebliche Speicherkapazität, was zu hohen Infrastrukturkosten führt. Die asynchrone Inferenz von SageMaker, eine Bereitstellungsoption, die Anfragen asynchron verarbeitet, reduziert die Kosten, indem die Instanzanzahl auf Null skaliert wird, wenn keine ausstehenden Anfragen vorliegen. In diesem Beitrag haben wir gezeigt, wie man große SageMaker JumpStart-Grundlagenmodelle auf asynchronen SageMaker-Endpunkten bereitstellt. Wir haben Codebeispiele mit dem SageMaker Python SDK, Boto3 und LangChain bereitgestellt, um verschiedene Methoden zum Aufrufen asynchroner Endpunkte und zum Abrufen von Ergebnissen zu veranschaulichen. Diese Techniken ermöglichen es Entwicklern und Forschern, die Kosten zu optimieren und gleichzeitig die Fähigkeiten von Basismodellen für fortgeschrittene Sprachverständnissysteme zu nutzen.

Weitere Informationen zu asynchroner Inferenz und SageMaker JumpStart finden Sie in den folgenden Beiträgen:

Über den Autor

David Gallitelli ist ein Specialist Solutions Architect für AI/ML in der EMEA-Region. Er hat seinen Sitz in Brüssel und arbeitet eng mit Kunden in den Benelux-Ländern zusammen. Er ist Entwickler, seit er sehr jung war und begann im Alter von 7 Jahren zu programmieren. Er begann an der Universität AI/ML zu lernen und hat sich seitdem darin verliebt.

• SEO-gestützte Content- und PR-Distribution. Holen Sie sich noch heute Verstärkung.
• PlatoData.Network Vertikale generative KI. Motiviere dich selbst. Hier zugreifen.
• PlatoAiStream. Web3-Intelligenz. Wissen verstärkt. Hier zugreifen.
• PlatoESG. Automobil / Elektrofahrzeuge, Kohlenstoff, CleanTech, Energie, Umwelt, Solar, Abfallwirtschaft. Hier zugreifen.
• PlatoHealth. Informationen zu Biotechnologie und klinischen Studien. Hier zugreifen.
• ChartPrime. Verbessern Sie Ihr Handelsspiel mit ChartPrime. Hier zugreifen.
• BlockOffsets. Modernisierung des Eigentums an Umweltkompensationen. Hier zugreifen.
• Quelle: https://aws.amazon.com/blogs/machine-learning/optimize-deployment-cost-of-amazon-sagemaker-jumpstart-foundation-models-with-amazon-sagemaker-asynchronous-endpoints/