Pakk og distribuer klassisk ML og LLM enkelt med Amazon SageMaker, del 1: PySDK Improvements | Amazon Web Services

Amazon SageMaker er en fullstendig administrert tjeneste som gjør det mulig for utviklere og dataforskere å raskt og enkelt bygge, trene og distribuere maskinlæringsmodeller (ML) i alle skalaer. SageMaker gjør det enkelt å distribuere modeller i produksjon direkte gjennom API-kall til tjenesten. Modeller er pakket inn i containere for robuste og skalerbare distribusjoner. Selv om det gir forskjellige inngangspunkter som SageMaker Python SDK, AWS SDK, SageMaker-konsollen og Amazon SageMaker Studio bærbare PC-er for å forenkle prosessen med å trene og distribuere ML-modeller i stor skala, leter kunder fortsatt etter bedre måter å distribuere modellene sine for lekeplasstesting og for å optimalisere produksjonsdistribusjoner.

Vi lanserer to nye måter å forenkle prosessen med å pakke og distribuere modeller ved hjelp av SageMaker.

I dette innlegget introduserer vi den nye SageMaker Python SDK ModelBuilder erfaring, som tar sikte på å minimere læringskurven for nye SageMaker-brukere som dataforskere, samtidig som de hjelper erfarne MLOps-ingeniører med å maksimere utnyttelsen av SageMaker-vertstjenester. Det reduserer kompleksiteten ved innledende oppsett og distribusjon, og ved å gi veiledning om beste praksis for å dra nytte av de fulle egenskapene til SageMaker. Vi gir detaljert informasjon og GitHub-eksempler for denne nye SageMaker-funksjonen.

Den andre nye lanseringen er å bruke den nye interaktive distribusjonsopplevelsen i SageMaker Studio. Vi diskuterer dette i del 2.

Å distribuere modeller til et SageMaker-endepunkt innebærer en rekke trinn for å gjøre modellen klar til å bli vert på et SageMaker-endepunkt. Dette innebærer å få modellartefakter i riktig format og struktur, lage slutningskode og spesifisere viktige detaljer som nettadressen til modellbildet, Amazon enkel lagringstjeneste (Amazon S3) plassering av modellartefakter, serialiserings- og deserialiseringstrinn, og nødvendig AWS identitets- og tilgangsadministrasjon (IAM) roller for å legge til rette for passende tilgangstillatelser. Etter dette krever en endepunktkonfigurasjon at man bestemmer slutningstypen og konfigurerer respektive parametere som forekomsttyper, antall og trafikkfordeling mellom modellvarianter.

For å hjelpe kundene våre ytterligere når de bruker SageMaker-hosting, introduserte vi den nye ModelBuilder klasse i SageMaker Python SDK, som gir følgende nøkkelfordeler når du distribuerer modeller til SageMaker-endepunkter:

• Forener distribusjonsopplevelsen på tvers av rammeverk – Den nye opplevelsen gir en konsistent arbeidsflyt for å distribuere modeller bygget ved hjelp av forskjellige rammeverk som PyTorch, TensorFlow og XGBoost. Dette forenkler distribusjonsprosessen.
• Automatiserer modellimplementering – Oppgaver som å velge passende beholdere, fange avhengigheter og håndtere serialisering/deserialisering er automatisert, noe som reduserer manuell innsats som kreves for distribusjon.
• Gir en jevn overgang fra lokalt til SageMaker vert endepunkt – Med minimale kodeendringer kan modeller enkelt overføres fra lokal testing til distribusjon på et SageMaker-endepunkt. Live logger gjør feilsøking sømløs.

Alt i alt, SageMaker ModelBuilder forenkler og effektiviserer modellpakkeprosessen for SageMaker-inferens ved å håndtere detaljer på lavt nivå og gir verktøy for testing, validering og optimalisering av endepunkter. Dette forbedrer utviklerproduktiviteten og reduserer feil.

I de følgende delene går vi dypt inn i detaljene i denne nye funksjonen. Vi diskuterer også hvordan du distribuerer modeller til SageMaker-hosting ved hjelp av ModelBuilder, noe som forenkler prosessen. Deretter leder vi deg gjennom noen få eksempler for ulike rammeverk for å distribuere både tradisjonelle ML-modeller og grunnmodellene som kraftgenererende AI bruker tilfeller.

Bli kjent med SageMaker ModelBuilder

Den nye ModelBuilder er en Python-klasse fokusert på å ta ML-modeller bygget ved hjelp av rammeverk, som XGBoost eller PyTorch, og konvertere dem til modeller som er klare for distribusjon på SageMaker. ModelBuilder gir en build() funksjon, som genererer artefaktene i henhold til modellserveren, og en deploy() funksjon for å distribuere lokalt eller til et SageMaker-endepunkt. Introduksjonen av denne funksjonen forenkler integrasjonen av modeller med SageMaker-miljøet, og optimaliserer dem for ytelse og skalerbarhet. Følgende diagram viser hvordan ModelBuilder fungerer på et høyt nivå.

ModelBuilder klasse

De ModelBuilder klasse gir forskjellige alternativer for tilpasning. Men for å distribuere rammemodellen forventer modellbyggeren bare modellen, input, output og rolle:

class ModelBuilder( model, # model id or model object role_arn, # IAM role schema_builder, # defines the input and output mode, # select between local deployment and depoy to SageMaker Endpoints ...
)

SchemaBuilder

De SchemaBuilder klasse lar deg definere input og output for endepunktet ditt. Den lar skjemabyggeren generere de tilsvarende rangeringsfunksjonene for serialisering og deserialisering av input og output. Følgende klassefil inneholder alle alternativene for tilpasning:

class SchemaBuilder( sample_input: Any, sample_output: Any, input_translator: CustomPayloadTranslator = None, output_translator: CustomPayloadTranslator = None
)

Men i de fleste tilfeller vil bare prøveinngang og utgang fungere. For eksempel:

input = "How is the demo going?"
output = "Comment la démo va-t-elle?"
schema = SchemaBuilder(input, output)

Ved å gi eksempelinndata og utdata, SchemaBuilder kan automatisk bestemme nødvendige transformasjoner, noe som gjør integrasjonsprosessen mer enkel. For mer avanserte brukstilfeller er det fleksibilitet til å tilby tilpassede oversettelsesfunksjoner for både input og output, noe som sikrer at mer komplekse datastrukturer også kan håndteres effektivt. Vi demonstrerer dette i de følgende avsnittene ved å distribuere forskjellige modeller med forskjellige rammeverk ModelBuilder.

Lokal modusopplevelse

I dette eksemplet bruker vi ModelBuilder å distribuere XGBoost-modellen lokalt. Du kan bruke Mode til å bytte mellom lokal testing og distribusjon til et SageMaker-endepunkt. Vi trener først XGBoost-modellen (lokalt eller i SageMaker) og lagrer modellartefakter i arbeidskatalogen:

# Train the model
model = XGBClassifier()
model.fit(X_train, y_train)
model.save_model(model_dir + "/my_model.xgb")

Deretter lager vi et ModelBuilder-objekt ved å sende det faktiske modellobjektet, den SchemaBuilder som bruker prøvetestinn- og utdataobjektene (samme input og output som vi brukte da vi trente og testet modellen) for å utlede serialiseringen som trengs. Merk at vi bruker Mode.LOCAL_CONTAINER for å spesifisere en lokal distribusjon. Etter det ringer vi bygge funksjon for automatisk å identifisere det støttede rammebeholderbildet samt skanne etter avhengigheter. Se følgende kode:

model_builder_local = ModelBuilder( model=model, schema_builder=SchemaBuilder(X_test, y_pred), role_arn=execution_role, mode=Mode.LOCAL_CONTAINER
)
xgb_local_builder = model_builder_local.build()

Endelig kan vi ringe deploy funksjon i modellobjektet, som også gir live logging for enklere feilsøking. Du trenger ikke spesifisere forekomsttype eller antall fordi modellen vil bli distribuert lokalt. Hvis du oppga disse parameterne, vil de bli ignorert. Denne funksjonen vil returnere prediktorobjektet som vi kan bruke til å forutsi med testdataene:

# note: all the serialization and deserialization is handled by the model builder.
predictor_local = xgb_local_builder.deploy(
# instance_type='ml.c5.xlarge',
# initial_instance_count=1
) # Make prediction for test data. predictor_local.predict(X_test)

Eventuelt kan du også kontrollere lasting av modellen og for- og etterbehandling ved hjelp av InferenceSpec. Vi gir mer detaljer senere i dette innlegget. Ved hjelp av LOCAL_CONTAINER er en fin måte å teste ut skriptet ditt lokalt før det distribueres til et SageMaker-endepunkt.

Referere til modellbygger-xgboost.ipynb eksempel for å teste ut distribusjon både lokalt og til et SageMaker-endepunkt ved hjelp av ModelBuilder.

Distribuer tradisjonelle modeller til SageMaker-endepunkter

I de følgende eksemplene viser vi hvordan du bruker ModelBuilder å distribuere tradisjonelle ML-modeller.

XGBoost-modeller

I likhet med forrige seksjon kan du distribuere en XGBoost-modell til et SageMaker-endepunkt ved å endre mode parameter når du oppretter ModelBuilder gjenstand:

model_builder = ModelBuilder( model=model, schema_builder=SchemaBuilder(sample_input=sample_input, sample_output=sample_output), role_arn=execution_role, mode=Mode.SAGEMAKER_ENDPOINT
)
xgb_builder = model_builder.build()
predictor = xgb_builder.deploy( instance_type='ml.c5.xlarge', initial_instance_count=1
)

Merk at når du distribuerer til SageMaker-endepunkter, må du spesifisere forekomsttype og antall forekomster når du kaller opp deploy funksjon.

Referere til modellbygger-xgboost.ipynb eksempel for å distribuere en XGBoost-modell.

Triton-modeller

Du kan bruke ModelBuilder å betjene PyTorch-modeller på Triton Inference Server. For det må du spesifisere model_server parameter som ModelServer.TRITON, bestå en modell, og ha en SchemaBuilder objekt, som krever eksempelinndata og utdata fra modellen. ModelBuilder tar seg av resten for deg.

model_builder = ModelBuilder( model=model, schema_builder=SchemaBuilder(sample_input=sample_input, sample_output=sample_output), role_arn=execution_role, model_server=ModelServer.TRITON, mode=Mode.SAGEMAKER_ENDPOINT
) triton_builder = model_builder.build() predictor = triton_builder.deploy( instance_type='ml.g4dn.xlarge', initial_instance_count=1
)

Referere til modellbygger-triton.ipynb å distribuere en modell med Triton.

Hugging Face-modeller

I dette eksemplet viser vi deg hvordan du distribuerer en forhåndsopplært transformatormodell levert av Hugging Face til SageMaker. Vi ønsker å bruke Hugging Face pipeline for å laste modellen, så vi lager en tilpasset slutningsspesifikasjon for ModelBuilder:

# custom inference spec with hugging face pipeline
class MyInferenceSpec(InferenceSpec): def load(self, model_dir: str): return pipeline("translation_en_to_fr", model="t5-small") def invoke(self, input, model): return model(input) inf_spec = MyInferenceSpec()

Vi definerer også input og output for inferensarbeidsbelastningen ved å definere SchemaBuilder objekt basert på modellens input og output:

schema = SchemaBuilder(value,output)

Så lager vi ModelBuilder objekt og distribuer modellen på et SageMaker-endepunkt etter samme logikk som vist i det andre eksemplet:

builder = ModelBuilder( inference_spec=inf_spec, mode=Mode.SAGEMAKER_ENDPOINT, # you can change it to Mode.LOCAL_CONTAINER for local testing schema_builder=schema, image_uri=image,
)
model = builder.build( role_arn=execution_role, sagemaker_session=sagemaker_session,
)
predictor = model.deploy( initial_instance_count=1, instance_type='ml.g5.2xlarge'
)

Referere til modellbygger-huggingface.ipynb å distribuere en Hugging Face-rørledningsmodell.

Distribuer grunnmodeller til SageMaker-endepunkter

I de følgende eksemplene viser vi hvordan du bruker ModelBuilder å distribuere grunnmodeller. Akkurat som modellene nevnt tidligere, er alt som kreves modell-ID.

Klemmer Face Hub

Hvis du ønsker å distribuere en grunnmodell fra Klemmer Face Hub, alt du trenger å gjøre er å bestå den forhåndstrente modell-ID-en. Følgende kodebit implementerer for eksempel meta-llama/Llama-2-7b-hf modell lokalt. Du kan endre modus til Mode.SAGEMAKER_ENDPOINT å distribuere til SageMaker-endepunkter.

model_builder = ModelBuilder( model="meta-llama/Llama-2-7b-hf", schema_builder=SchemaBuilder(sample_input, sample_output), model_path="/home/ec2-user/SageMaker/LoadTestResources/meta-llama2-7b", #local path where artifacts will be saved mode=Mode.LOCAL_CONTAINER, env_vars={ # Llama 2 is a gated model and requires a Hugging Face Hub token. "HUGGING_FACE_HUB_TOKEN": "<YourHuggingFaceToken>" }
)
model = model_builder.build()
local_predictor = model.deploy()

For gatede modeller på Hugging Face Hub, må du be om tilgang via Hugging Face Hub og bruke den tilknyttede nøkkelen ved å sende den som miljøvariabel HUGGING_FACE_HUB_TOKEN. Noen Hugging Face-modeller kan kreve pålitelig fjernkontrollkode. Den kan også settes som en miljøvariabel ved å bruke HF_TRUST_REMOTE_CODE. Som standard, ModelBuilder vil bruke en Hugging Face Text Generation Inference (TGI) container som underliggende container for Hugging Face-modeller. Hvis du ønsker å bruke AWS Large Model Inference (LMI) containere, kan du sette opp model_server parameter som ModelServer.DJL_SERVING når du konfigurerer ModelBuilder gjenstand.

Et pent trekk ved ModelBuilder er muligheten til å kjøre lokal innstilling av beholderparametrene når du bruker LOCAL_CONTAINER modus. Denne funksjonen kan brukes ved å kjøre tuned_model = model.tune().

Referere til demo-modellbygger-huggingface-llama2.ipynb å distribuere en Hugging Face Hub-modell.

SageMaker JumpStart

Amazon SageMaker JumpStart tilbyr også en rekke ferdigtrente fundamentmodeller. Akkurat som prosessen med å distribuere en modell fra Hugging Face Hub, kreves modell-ID. Å distribuere en SageMaker JumpStart-modell til et SageMaker-endepunkt er like enkelt som å kjøre følgende kode:

model_builder = ModelBuilder( model="huggingface-llm-falcon-7b-bf16", schema_builder=SchemaBuilder(sample_input, sample_output), role_arn=execution_role
) sm_ep_model = model_builder.build() predictor = sm_ep_model.deploy()

For alle tilgjengelige SageMaker JumpStart-modell-IDer, se Innebygde algoritmer med forhåndstrent modellbord. Referere til modellbygger-jumpstart-falcon.ipynb å distribuere en SageMaker JumpStart-modell.

Inferenskomponent

ModelBulder lar deg bruke den nye inferenskomponentfunksjonen i SageMaker for å distribuere modeller. For mer informasjon om inferenskomponenter, se Reduser modellimplementeringskostnadene med 50 % i gjennomsnitt ved å bruke SageMakers siste funksjoner. Du kan bruke inferenskomponenter for distribusjon med ModelBuilder ved å spesifisere endpoint_type=EndpointType.INFERENCE_COMPONENT_BASED i deploy() metode. Du kan også bruke tune() metode, som henter det optimale antallet akseleratorer, og modifiser den om nødvendig.

resource_requirements = ResourceRequirements( requests={ "num_accelerators": 4, "memory": 1024, "copies": 1, }, limits={},
) goldfinch_predictor_2 = model_2.deploy( mode=Mode.SAGEMAKER_ENDPOINT, endpoint_type=EndpointType.INFERENCE_COMPONENT_BASED, ... )

Referere til modellbygger-inferens-komponent.ipynb å distribuere en modell som en slutningskomponent.

Tilpass ModelBuilder-klassen

De ModelBuilder klasse lar deg tilpasse modelllasting ved hjelp av InferenceSpec.

I tillegg kan du kontrollere nyttelast og responsserialisering og deserialisering og tilpasse for- og etterbehandling ved å bruke CustomPayloadTranslator. I tillegg, når du trenger å utvide våre forhåndsbygde containere for modelldistribusjon på SageMaker, kan du bruke ModelBuilder å håndtere modellpakkeprosessen. I denne neste delen gir vi flere detaljer om disse egenskapene.

Inferensspes

Inferensspes tilbyr et ekstra lag med tilpasning. Den lar deg definere hvordan modellen lastes og hvordan den skal håndtere innkommende slutningsforespørsler. Gjennom InferenceSpec, kan du definere tilpassede lasteprosedyrer for modellene dine, og omgå standard lastemekanismer. Denne fleksibiliteten er spesielt gunstig når du arbeider med ikke-standardmodeller eller tilpassede inferensrørledninger. Invoke-metoden kan tilpasses, og gir deg muligheten til å skreddersy hvordan modellen behandler innkommende forespørsler (forbehandling og etterbehandling). Denne tilpasningen kan være avgjørende for å sikre at slutningsprosessen stemmer overens med de spesifikke behovene til modellen. Se følgende kode:

class InferenceSpec(abc.ABC): @abc.abstractmethod def load(self, model_dir: str): pass @abc.abstractmethod def invoke(self, input_object: object, model: object): pass

Følgende kode viser et eksempel på bruk av denne klassen:

class MyInferenceSpec(InferenceSpec): def load(self, model_dir: str): return // model object def invoke(self, input, model): return model(input)

CustomPayloadTranslator

Når du påkaller SageMaker-endepunkter, sendes dataene gjennom HTTP-nyttelaster med forskjellige MIME-typer. For eksempel, et bilde som sendes til endepunktet for slutning må konverteres til byte på klientsiden og sendes gjennom HTTP-nyttelasten til endepunktet. Når endepunktet mottar nyttelasten, må det deserialisere bytestrengen tilbake til datatypen som forventes av modellen (også kjent som deserialisering på serversiden). Etter at modellen er ferdig med prediksjonen, må resultatene serialiseres til byte som kan sendes tilbake gjennom HTTP-nyttelasten til brukeren eller klienten. Når klienten mottar responsbytedataene, må den utføre deserialisering på klientsiden for å konvertere bytedataene tilbake til det forventede dataformatet, for eksempel JSON. På et minimum, du må konvertere dataene for følgende (som nummerert i følgende diagram):

1. Serialisering av slutningsforespørsel (håndteres av klienten)
2. Deserialisering av slutningsforespørsel (håndteres av serveren eller algoritmen)
3. Påkalle modellen mot nyttelasten
4. Sender tilbake nyttelasten
5. Inferenssvar serialisering (håndteres av serveren eller algoritmen)
6. Deserialisering av slutningssvar (håndteres av klienten)

Følgende diagram viser prosessen med serialisering og deserialisering under påkallingsprosessen.

I den følgende kodebiten viser vi et eksempel på CustomPayloadTranslator når ytterligere tilpasning er nødvendig for å håndtere både serialisering og deserialisering på henholdsvis klient- og serversiden:

from sagemaker.serve import CustomPayloadTranslator # request translator
class MyRequestTranslator(CustomPayloadTranslator): # This function converts the payload to bytes - happens on client side def serialize_payload_to_bytes(self, payload: object) -> bytes: # converts the input payload to bytes ... ... return //return object as bytes # This function converts the bytes to payload - happens on server side def deserialize_payload_from_stream(self, stream) -> object: # convert bytes to in-memory object ... ... return //return in-memory object # response translator class MyResponseTranslator(CustomPayloadTranslator): # This function converts the payload to bytes - happens on server side def serialize_payload_to_bytes(self, payload: object) -> bytes: # converts the response payload to bytes ... ... return //return object as bytes # This function converts the bytes to payload - happens on client side def deserialize_payload_from_stream(self, stream) -> object: # convert bytes to in-memory object ... ... return //return in-memory object

på demo-modellbygger-pytorch.ipynb notebook, viser vi hvordan du enkelt kan distribuere en PyTorch-modell til et SageMaker-endepunkt ved hjelp av ModelBuilder med CustomPayloadTranslator og InferenceSpec klasse.

Scenemodell for utplassering

Hvis du vil iscenesette modellen for slutning eller i modellregisteret, kan du bruke model.create() or model.register(). Den aktiverte modellen opprettes på tjenesten, og deretter kan du distribuere senere. Se følgende kode:

model_builder = ModelBuilder( model=model, schema_builder=SchemaBuilder(X_test, y_pred), role_arn=execution_role, )
deployable_model = model_builder.build() deployable_model.create() # deployable_model.register() for model registry

Bruk tilpassede beholdere

SageMaker gir forhåndsbygde Docker-bilder for de innebygde algoritmene og de støttede rammene for dyp læring som brukes til trening og slutninger. Hvis en forhåndsbygd SageMaker-beholder ikke oppfyller alle kravene dine, kan du utvide det eksisterende bildet for å imøtekomme dine behov. Ved å utvide et forhåndsbygget bilde kan du bruke de medfølgende dyplæringsbibliotekene og innstillingene uten å måtte lage et bilde fra bunnen av. For mer informasjon om hvordan du utvider de forhåndsbygde beholderne, se SageMaker-dokumentet. ModelBuilder støtter brukstilfeller når du tar med dine egne containere som er utvidet fra våre forhåndsbygde Docker-containere.

For å bruke ditt eget beholderbilde i dette tilfellet, må du angi feltene image_uri og model_server når du definerer ModelBuilder:

model_builder = ModelBuilder( model=model, # Pass in the actual model object. its "predict" method will be invoked in the endpoint. schema_builder=SchemaBuilder(X_test, y_pred), # Pass in a "SchemaBuilder" which will use the sample test input and output objects to infer the serialization needed. role_arn=execution_role, image_uri=image_uri, # REQUIRED FOR BYOC: Passing in image hosted in personal ECR Repo model_server=ModelServer.TORCHSERVE, # REQUIRED FOR BYOC: Passing in model server of choice mode=Mode.SAGEMAKER_ENDPOINT, dependencies={"auto": True, "custom": ["protobuf==3.20.2"]}
)

Her, den image_uri vil være beholderbildet ARN som er lagret i kontoen din Amazon Elastic Container Registry (Amazon ECR) depot. Ett eksempel er vist som følger:

# Pulled the xgboost:1.7-1 DLC and pushed to personal ECR repo
image_uri = "<your_account_id>.dkr.ecr.us-west-2.amazonaws.com/my-byoc:xgb"

når image_uri er satt, under ModelBuilder byggeprosessen, vil den hoppe over automatisk gjenkjenning av bildet ettersom bilde-URIen er gitt. Hvis model_server ikke er satt i ModelBuilder, vil du motta en valideringsfeilmelding, for eksempel:

ValueError: Model_server must be set when image_uri is set. Supported model servers: {<ModelServer.TRITON: 5>, <ModelServer.DJL_SERVING: 4>, <ModelServer.TORCHSERVE: 1>}

Fra og med publiseringen av dette innlegget, ModelBuilder støtter å ta med egne containere som er forlenget fra vår forhåndsbygde DLC-beholderbilder eller containere bygget med modellservere som Deep Java Library (DJL), Text Generation Inference (TGI), TorchServeog Triton-inferensserver.

Egendefinerte avhengigheter

Når du kjører ModelBuilder.build(), som standard fanger den automatisk Python-miljøet inn i en requirements.txt fil og installerer den samme avhengigheten i beholderen. Noen ganger vil imidlertid ditt lokale Python-miljø komme i konflikt med miljøet i beholderen. ModelBuilder gir deg en enkel måte å endre de fangede avhengighetene for å fikse slike avhengighetskonflikter ved å tillate deg å gi dine egendefinerte konfigurasjoner i ModelBuilder. Merk at dette kun er for TorchServe og Triton med InferenceSpec. For eksempel kan du spesifisere inngangsparameteravhengighetene, som er en Python-ordbok, i ModelBuilder som følger:

dependency_config = { "auto" = True, "requirements" = "/path/to/your/requirements.txt" "custom" = ["module>=1.2.3,<1.5", "boto3==1.16.*", "some_module@http://some/url"]
} ModelBuilder( # Other params dependencies=dependency_config,
).build()

Vi definerer følgende felt:

• auto – Om du skal prøve å automatisk fange opp avhengighetene i miljøet ditt.
• krav – En streng av veien til din egen requirements.txt fil. (Dette er valgfritt.)
• skikk – En liste over eventuelle andre egendefinerte avhengigheter som du vil legge til eller endre. (Dette er valgfritt.)

Hvis samme modul er spesifisert flere steder, custom vil ha høyeste prioritet, da requirementsog auto vil ha lavest prioritet. La oss for eksempel si at under autodeteksjon, ModelBuilder oppdager numpy==1.25Og requirements.txt fil er gitt som spesifiserer numpy>=1.24,<1.26. I tillegg er det en tilpasset avhengighet: custom = ["numpy==1.26.1"]. I dette tilfellet, numpy==1.26.1 vil bli plukket når vi installerer avhengigheter i containeren.

Rydd opp

Når du er ferdig med å teste modellene, som en beste praksis, slett endepunktet for å spare kostnader hvis endepunktet ikke lenger er nødvendig. Du kan følge Rydd opp delen i hver av demo-notatbøkene eller bruk følgende kode for å slette modellen og endepunktet opprettet av demoen:

predictor.delete_model()
predictor.delete_endpoint()

konklusjonen

Den nye SageMaker ModelBuilder-funksjonen forenkler prosessen med å distribuere ML-modeller til produksjon på SageMaker. Ved å håndtere mange av de komplekse detaljene bak kulissene, reduserer ModelBuilder læringskurven for nye brukere og maksimerer utnyttelsen for erfarne brukere. Med bare noen få linjer med kode kan du distribuere modeller med innebygde rammeverk som XGBoost, PyTorch, Triton og Hugging Face, samt modeller levert av SageMaker JumpStart til robuste, skalerbare endepunkter på SageMaker.

Vi oppfordrer alle SageMaker-brukere til å prøve ut denne nye funksjonen ved å henvise til ModelBuilder dokumentasjonsside. ModelBuilder er tilgjengelig nå for alle SageMaker-brukere uten ekstra kostnad. Dra nytte av denne forenklede arbeidsflyten for å få modellene dine distribuert raskere. Vi ser frem til å høre hvordan ModelBuilder akselererer livssyklusen din for modellutvikling!

Spesiell takk til Sirisha Upadhyayala, Raymond Liu, Gary Wang, Dhawal Patel, Deepak Garg og Ram Vegiraju.

Om forfatterne

Melanie Li, PhD, er en senior AI/ML-spesialist TAM ved AWS med base i Sydney, Australia. Hun hjelper bedriftskunder med å bygge løsninger ved hjelp av toppmoderne AI/ML-verktøy på AWS og gir veiledning om arkitektur og implementering av ML-løsninger med beste praksis. På fritiden elsker hun å utforske naturen og tilbringe tid med familie og venner.

Marc Karp er en ML-arkitekt med Amazon SageMaker Service-teamet. Han fokuserer på å hjelpe kunder med å designe, distribuere og administrere ML-arbeidsmengder i stor skala. På fritiden liker han å reise og utforske nye steder.

Sam Edwards, er en skyingeniør (AI/ML) ved AWS Sydney, spesialisert i maskinlæring og Amazon SageMaker. Han brenner for å hjelpe kunder med å løse problemer knyttet til arbeidsflyter for maskinlæring og skape nye løsninger for dem. Utenom jobben liker han å spille racketsport og reise.

Raghu Ramesha er senior ML Solutions Architect med Amazon SageMaker Service-teamet. Han fokuserer på å hjelpe kunder med å bygge, distribuere og migrere ML-produksjonsarbeidsmengder til SageMaker i stor skala. Han spesialiserer seg på maskinlæring, AI og datasynsdomener, og har en mastergrad i informatikk fra UT Dallas. På fritiden liker han å reise og fotografere.

Shiva Raaj Kotini jobber som hovedproduktsjef i Amazon SageMaker-produktporteføljen. Han fokuserer på modelldistribusjon, ytelsesjustering og optimalisering i SageMaker for slutninger.

Mohan Gandhi er senior programvareingeniør hos AWS. Han har vært hos AWS de siste 10 årene og har jobbet med ulike AWS-tjenester som EMR, EFA og RDS. For tiden er han fokusert på å forbedre SageMaker Inference Experience. På fritiden liker han fotturer og maraton.

• 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. Karbon, CleanTech, Energi, Miljø, Solenergi, Avfallshåndtering. Tilgang her.
• PlatoHelse. Bioteknologisk og klinisk etterretning. Tilgang her.
• kilde: https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-1-pysdk-improvements/