Împachetați și implementați cu ușurință ML și LLM-uri clasice cu Amazon SageMaker, partea 1: Îmbunătățiri PySDK | Amazon Web Services

Amazon SageMaker este un serviciu complet gestionat care permite dezvoltatorilor și cercetătorilor de date să construiască, să antreneze și să implementeze rapid și fără efort modele de învățare automată (ML) la orice scară. SageMaker simplifică implementarea modelelor în producție direct prin apeluri API către serviciu. Modelele sunt ambalate în containere pentru implementări robuste și scalabile. Deși oferă diverse puncte de intrare, cum ar fi SDK-ul SageMaker Python, SDK-urile AWS, consola SageMaker și Amazon SageMaker Studio notebook-uri pentru a simplifica procesul de instruire și implementare a modelelor ML la scară, clienții caută în continuare modalități mai bune de a-și implementa modelele pentru testarea terenului de joacă și de a optimiza implementările de producție.

Lansăm două noi modalități de a simplifica procesul de ambalare și implementare a modelelor folosind SageMaker.

În această postare, vă prezentăm noul SDK SageMaker Python ModelBuilder experiență, care urmărește să minimizeze curba de învățare pentru noii utilizatori SageMaker, cum ar fi oamenii de știință de date, ajutând în același timp inginerii experimentați MLOps să maximizeze utilizarea serviciilor de găzduire SageMaker. Reduce complexitatea instalării și implementării inițiale și oferind îndrumări cu privire la cele mai bune practici pentru a profita de capacitățile complete ale SageMaker. Oferim informații detaliate și exemple GitHub pentru această nouă capacitate SageMaker.

Cealaltă lansare nouă este utilizarea noii experiențe de implementare interactivă în SageMaker Studio. Discutăm acest lucru în partea a 2-a.

Implementarea modelelor pe un punct final SageMaker presupune o serie de pași pentru a pregăti modelul pentru a fi găzduit pe un punct final SageMaker. Aceasta implică obținerea artefactelor modelului în formatul și structura corecte, crearea codului de inferență și specificarea detaliilor esențiale, cum ar fi adresa URL a imaginii modelului, Serviciul Amazon de stocare simplă (Amazon S3) locația artefactelor modelului, pașii de serializare și deserializare și necesar Gestionarea identității și accesului AWS (IAM) pentru a facilita permisiunile de acces adecvate. După aceasta, o configurație a punctului final necesită determinarea tipului de inferență și configurarea parametrilor respectivi, cum ar fi tipurile de instanțe, numărătoarea și distribuția traficului între variantele de model.

Pentru a ne ajuta și mai mult clienții când folosesc găzduirea SageMaker, am introdus noul ModelBuilder clasa din SageMaker Python SDK, care aduce următoarele beneficii cheie atunci când implementați modele la punctele finale SageMaker:

• Unifică experiența de implementare între cadre – Noua experiență oferă un flux de lucru consistent pentru implementarea modelelor construite folosind diferite cadre precum PyTorch, TensorFlow și XGBoost. Acest lucru simplifică procesul de implementare.
• Automatizează implementarea modelului – Sarcini precum selectarea containerelor adecvate, capturarea dependențelor și gestionarea serializării/dezerializarii sunt automatizate, reducând efortul manual necesar pentru implementare.
• Oferă o tranziție lină de la punctul final local la găzduit SageMaker – Cu modificări minime de cod, modelele pot fi trecute cu ușurință de la testarea locală la implementarea pe un punct final SageMaker. Jurnalele live fac depanarea fără probleme.

În general, SageMaker ModelBuilder simplifică și eficientizează procesul de ambalare a modelului pentru inferența SageMaker prin gestionarea detaliilor de nivel scăzut și oferă instrumente pentru testarea, validarea și optimizarea punctelor finale. Acest lucru îmbunătățește productivitatea dezvoltatorului și reduce erorile.

În secțiunile următoare, ne aprofundăm detaliile acestei noi funcții. De asemenea, discutăm despre cum să implementăm modele pe găzduirea SageMaker folosind ModelBuilder, ceea ce simplifică procesul. Apoi vă prezentăm câteva exemple pentru diferite cadre pentru a implementa atât modele tradiționale ML, cât și modele de bază care alimentează cazurile de utilizare a AI generativă.

Cunoașterea SageMaker ModelBuilder

Noul ModelBuilder este o clasă Python axată pe preluarea modelelor ML construite folosind cadre, cum ar fi XGBoost sau PyTorch, și convertirea lor în modele care sunt gata pentru implementare pe SageMaker. ModelBuilder oferă o build() funcția, care generează artefactele conform serverului model și a deploy() funcție de implementare local sau la un punct final SageMaker. Introducerea acestei caracteristici simplifică integrarea modelelor cu mediul SageMaker, optimizându-le pentru performanță și scalabilitate. Următoarea diagramă arată cum ModelBuilder lucrează la nivel înalt.

Clasa ModelBuilder

ModelBuilder clasa oferă diferite opțiuni de personalizare. Cu toate acestea, pentru a implementa modelul cadru, generatorul de model se așteaptă doar la model, intrare, ieșire și rol:

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

SchemaBuilder clasa vă permite să definiți intrarea și ieșirea pentru punctul final. Acesta permite constructorului de scheme să genereze funcțiile de marshaling corespunzătoare pentru serializarea și deserializarea intrării și ieșirii. Următorul fișier de clasă oferă toate opțiunile de personalizare:

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

Cu toate acestea, în majoritatea cazurilor, ar funcționa doar intrarea și ieșirea eșantionului. De exemplu:

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

Prin furnizarea de eșantion de intrare și de ieșire, SchemaBuilder poate determina automat transformările necesare, făcând procesul de integrare mai simplu. Pentru cazuri de utilizare mai avansate, există flexibilitate de a oferi funcții de traducere personalizate atât pentru intrare, cât și pentru ieșire, asigurând că structurile de date mai complexe pot fi, de asemenea, gestionate eficient. Demonstrăm acest lucru în secțiunile următoare prin implementarea diferitelor modele cu diferite cadre de utilizare ModelBuilder.

Experiență în modul local

În acest exemplu, folosim ModelBuilder pentru a implementa modelul XGBoost la nivel local. Puteți utiliza Modul pentru a comuta între testarea locală și implementarea la un punct final SageMaker. Antrenăm mai întâi modelul XGBoost (local sau în SageMaker) și stocăm artefactele modelului în directorul de lucru:

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

Apoi creăm un obiect ModelBuilder prin trecerea obiectului model real, the SchemaBuilder care folosește eșantionul de obiecte de intrare și ieșire de testare (aceeași intrare și ieșire pe care le-am folosit la antrenarea și testarea modelului) pentru a deduce seria necesară. Rețineți că folosim Mode.LOCAL_CONTAINER pentru a specifica o implementare locală. După aceea, numim construi funcția de identificare automată a imaginii containerului cadru suportat, precum și de scanare pentru dependențe. Vezi următorul cod:

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

În cele din urmă, putem numi deploy funcția din obiectul model, care oferă, de asemenea, înregistrare în timp real pentru o depanare mai ușoară. Nu trebuie să specificați tipul sau numărul instanței, deoarece modelul va fi implementat local. Dacă ați furnizat acești parametri, aceștia vor fi ignorați. Această funcție va returna obiectul predictor pe care îl putem folosi pentru a face predicții cu datele de testare:

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

Opțional, puteți controla și încărcarea modelului și preprocesarea și postprocesarea folosind InferenceSpec. Oferim mai multe detalii mai târziu în această postare. Folosind LOCAL_CONTAINER este o modalitate excelentă de a vă testa scriptul la nivel local înainte de a fi implementat la un punct final SageMaker.

Consultați model-builder-xgboost.ipynb exemplu pentru a testa implementarea atât local, cât și la un punct final SageMaker folosind ModelBuilder.

Implementați modele tradiționale la punctele finale SageMaker

În următoarele exemple, vă prezentăm modul de utilizare ModelBuilder pentru a implementa modele tradiționale ML.

Modele XGBoost

Similar cu secțiunea anterioară, puteți implementa un model XGBoost la un punct final SageMaker schimbând mode parametrul la crearea ModelBuilder obiect:

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
)

Rețineți că atunci când implementați la punctele finale SageMaker, trebuie să specificați tipul de instanță și numărul de instanțe atunci când apelați deploy Funcția.

Consultați model-builder-xgboost.ipynb exemplu pentru a implementa un model XGBoost.

Modele Triton

Poți să folosești ModelBuilder pentru a servi modelele PyTorch Triton Inference Server. Pentru asta, trebuie să specificați model_server parametru ca ModelServer.TRITON, trece un model și ai un SchemaBuilder obiect, care necesită eșantion de intrări și ieșiri din model. ModelBuilder se va ocupa de restul pentru tine.

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
)

A se referi la model-builder-triton.ipynb pentru a implementa un model cu Triton.

Modele Hugging Face

În acest exemplu, vă arătăm cum să implementați un model de transformator pre-antrenat furnizat de Hugging Face către SageMaker. Vrem să folosim Fața Îmbrățișată pipeline pentru a încărca modelul, așa că creăm o specificație de inferență personalizată pentru 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()

De asemenea, definim intrarea și ieșirea sarcinii de lucru de inferență prin definirea SchemaBuilder obiect bazat pe intrarea și ieșirea modelului:

schema = SchemaBuilder(value,output)

Apoi creăm ModelBuilder obiect și implementați modelul pe un punct final SageMaker urmând aceeași logică ca cea prezentată în celălalt exemplu:

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

A se referi la model-builder-huggingface.ipynb pentru a implementa un model de conductă Hugging Face.

Implementați modele de bază la punctele finale SageMaker

În următoarele exemple, vă prezentăm modul de utilizare ModelBuilder pentru a implementa modele de fundație. La fel ca modelele menționate mai devreme, tot ceea ce este necesar este ID-ul modelului.

Hugging Face Hub

Dacă doriți să implementați un model de fundație din Hugging Face Hub, tot ce trebuie să faceți este să treceți ID-ul modelului pre-antrenat. De exemplu, următorul fragment de cod implementează meta-lama/Llama-2-7b-hf model la nivel local. Puteți schimba modul în Mode.SAGEMAKER_ENDPOINT pentru implementare la punctele finale SageMaker.

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

Pentru modelele închise pe Hugging Face Hub, trebuie să solicitați acces prin Hugging Face Hub și să utilizați cheia asociată transmițând-o ca variabilă de mediu HUGGING_FACE_HUB_TOKEN. Unele modele Hugging Face pot necesita un cod de încredere la distanță. Poate fi setat și ca variabilă de mediu folosind HF_TRUST_REMOTE_CODE. În mod implicit, ModelBuilder va folosi o Inferență de generare a textului Hugging Face (ȚINE) container ca container de bază pentru modelele Hugging Face. Dacă doriți să utilizați AWS Large Model Inference (containere LMI)., puteți configura model_server parametru ca ModelServer.DJL_SERVING când configurați ModelBuilder obiect.

O caracteristică îngrijită a ModelBuilder este capacitatea de a rula reglarea locală a parametrilor containerului atunci când utilizați LOCAL_CONTAINER modul. Această caracteristică poate fi utilizată pur și simplu rulând tuned_model = model.tune().

A se referi la demo-model-builder-huggingface-llama2.ipynb pentru a implementa un model Hugging Face Hub.

SageMaker JumpStart

Amazon SageMaker JumpStart oferă, de asemenea, o serie de modele de fond de ten pre-instruite. La fel ca procesul de implementare a unui model de la Hugging Face Hub, este necesar ID-ul modelului. Implementarea unui model SageMaker JumpStart la un punct final SageMaker este la fel de simplă ca și rularea următorului cod:

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

Pentru toate ID-urile de model SageMaker JumpStart disponibile, consultați Algoritmi încorporați cu tabel model pre-antrenat. A se referi la model-builder-jumpstart-falcon.ipynb pentru a implementa un model SageMaker JumpStart.

Componenta de inferență

ModelBulder vă permite să utilizați noua capacitate de componentă de inferență din SageMaker pentru a implementa modele. Pentru mai multe informații despre componentele de inferență, consultați Reduceți costurile de implementare a modelelor cu 50% în medie folosind cele mai recente caracteristici ale SageMaker. Puteți utiliza componente de inferență pentru implementare cu ModelBuilder prin precizarea endpoint_type=EndpointType.INFERENCE_COMPONENT_BASED în deploy() metodă. De asemenea, puteți utiliza tune() metoda, care preia numărul optim de acceleratoare și îl modifică dacă este necesar.

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, ... )

A se referi la model-builder-inference-component.ipynb pentru a implementa un model ca componentă de inferență.

Personalizați clasa ModelBuilder

ModelBuilder clasa vă permite să personalizați încărcarea modelului folosind InferenceSpec.

În plus, puteți controla sarcina utilă și serializarea și deserializarea răspunsului și puteți personaliza preprocesarea și postprocesarea folosind CustomPayloadTranslator. În plus, atunci când trebuie să extindeți containerele noastre pre-construite pentru implementarea modelului pe SageMaker, puteți utiliza ModelBuilder pentru a gestiona procesul de ambalare a modelului. În această secțiune următoare, oferim mai multe detalii despre aceste capabilități.

InferenceSpec

InferenceSpec oferă un strat suplimentar de personalizare. Vă permite să definiți modul în care este încărcat modelul și cum va gestiona cererile de inferență primite. Prin InferenceSpec, puteți defini proceduri de încărcare personalizate pentru modelele dvs., ocolind mecanismele de încărcare implicite. Această flexibilitate este deosebit de benefică atunci când lucrați cu modele non-standard sau conducte de inferență personalizate. Metoda de invocare poate fi personalizată, oferindu-vă posibilitatea de a personaliza modul în care modelul procesează cererile primite (preprocesare și postprocesare). Această personalizare poate fi esențială pentru a se asigura că procesul de inferență se aliniază cu nevoile specifice ale modelului. Vezi următorul cod:

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

Următorul cod arată un exemplu de utilizare a acestei clase:

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

CustomPayloadTranslator

La invocarea punctelor finale SageMaker, datele sunt trimise prin încărcături utile HTTP cu diferite tipuri MIME. De exemplu, o imagine trimisă la punctul final pentru inferență trebuie convertită în octeți din partea clientului și trimisă prin încărcarea utilă HTTP către punctul final. Când punctul final primește sarcina utilă, trebuie să deserializeze șirul de octeți înapoi la tipul de date așteptat de model (cunoscut și ca deserializare pe partea serverului). După ce modelul termină predicția, rezultatele trebuie serializate în octeți care pot fi trimiși înapoi prin încărcarea utilă HTTP către utilizator sau client. Când clientul primește datele octeților de răspuns, trebuie să efectueze deserializarea pe partea client pentru a converti datele octeților înapoi în formatul de date așteptat, cum ar fi JSON. La minim, trebuie să convertiți datele pentru următoarele (așa cum este numerotat în diagrama următoare):

1. Serializarea cererii de inferență (tratată de client)
2. Deserializarea cererii de inferență (tratată de server sau de algoritm)
3. Invocarea modelului pe sarcina utilă
4. Se trimite înapoi sarcina de răspuns
5. Serializarea răspunsului la inferență (tratată de server sau de algoritm)
6. Deserializarea răspunsului prin inferență (tratată de client)

Următoarea diagramă arată procesul de serializare și deserializare în timpul procesului de invocare.

În următorul fragment de cod, arătăm un exemplu de CustomPayloadTranslator atunci când este nevoie de personalizare suplimentară pentru a gestiona atât serializarea, cât și deserializarea în partea client și, respectiv, pe server:

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

În demo-model-builder-pytorch.ipynb notebook, demonstrăm cum să implementați cu ușurință un model PyTorch la un punct final SageMaker folosind ModelBuilder cu CustomPayloadTranslator si InferenceSpec clasă.

Model de etapă pentru implementare

Dacă doriți să puneți în scenă modelul pentru inferență sau în registrul modelului, puteți utiliza model.create() or model.register(). Modelul activat este creat pe serviciu și apoi îl puteți implementa mai târziu. Vezi următorul cod:

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

Folosiți containere personalizate

SageMaker oferă imagini Docker prefabricate pentru algoritmii încorporați și cadrele de învățare profundă acceptate utilizate pentru antrenament și inferență. Dacă un container SageMaker prefabricat nu vă îndeplinește toate cerințele, puteți extinde imaginea existentă pentru a se potrivi nevoilor dumneavoastră. Prin extinderea unei imagini pre-construite, puteți utiliza bibliotecile și setările de deep learning incluse fără a fi nevoie să creați o imagine de la zero. Pentru mai multe detalii despre cum să extindeți containerele prefabricate, consultați documentul SageMaker. ModelBuilder acceptă cazuri de utilizare atunci când aduceți propriile containere care sunt extinse din containerele noastre Docker prefabricate.

Pentru a utiliza propria imagine de container în acest caz, trebuie să setați câmpurile image_uri și model_server la definire 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"]}
)

Aici image_uri va fi ARN-ul imaginii containerului care este stocat în contul dvs Registrul Amazon de containere elastice (Amazon ECR). Un exemplu este prezentat după cum urmează:

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

Cand image_uri este setat, în timpul ModelBuilder procesul de construire, va omite detectarea automată a imaginii pe măsură ce este furnizat URI-ul imaginii. Dacă model_server nu este setat în ModelBuilder, veți primi un mesaj de eroare de validare, de exemplu:

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

De la publicarea acestei postări, ModelBuilder sprijină aducerea propriilor containere care sunt extinse de la noi imagini de containere DLC pre-construite sau containere construite cu serverele model precum Biblioteca Deep Java (DJL), Inferență de generare a textului (TGI), TorchServe, și Server de inferență Triton.

Dependențe personalizate

Când alergi ModelBuilder.build(), în mod implicit, captează automat mediul dvs. Python într-un requirements.txt fișier și instalează aceeași dependență în container. Cu toate acestea, uneori mediul dvs. local Python va intra în conflict cu mediul din container. ModelBuilder oferă o modalitate simplă de a modifica dependențele capturate pentru a remedia astfel de conflicte de dependență, permițându-vă să furnizați configurațiile personalizate în ModelBuilder. Rețineți că acest lucru este doar pentru TorchServe și Triton cu InferenceSpec. De exemplu, puteți specifica dependențele parametrilor de intrare, care este un dicționar Python, în ModelBuilder, după cum urmează:

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

Definim urmatoarele campuri:

• Auto – Dacă să încercați să capturați automat dependențele din mediul dvs.
• Cerințe – Un șir al căii către a ta requirements.txt fişier. (Acest lucru este opțional.)
• personalizat – O listă cu orice alte dependențe personalizate pe care doriți să le adăugați sau să le modificați. (Acest lucru este opțional.)

Dacă același modul este specificat în mai multe locuri, custom atunci va avea cea mai mare prioritate requirements, și auto va avea cea mai mică prioritate. De exemplu, să presupunem că în timpul detectării automate, ModelBuilder Detectează numpy==1.25, Precum și o requirements.txt este furnizat un fișier care specifică numpy>=1.24,<1.26. În plus, există o dependență personalizată: custom = ["numpy==1.26.1"]. În acest caz, numpy==1.26.1 va fi ales atunci când instalăm dependențe în container.

A curăța

Când ați terminat de testat modelele, ca cea mai bună practică, ștergeți punctul final pentru a economisi costuri dacă punctul final nu mai este necesar. Puteți urmări A curăța secțiunea din fiecare dintre blocnotesurile demonstrative sau utilizați următorul cod pentru a șterge modelul și punctul final creat de demonstrație:

predictor.delete_model()
predictor.delete_endpoint()

Concluzie

Noua capacitate SageMaker ModelBuilder simplifică procesul de implementare a modelelor ML în producție pe SageMaker. Gestionând multe dintre detaliile complexe din culise, ModelBuilder reduce curba de învățare pentru utilizatorii noi și maximizează utilizarea pentru utilizatorii experimentați. Cu doar câteva linii de cod, puteți implementa modele cu cadre încorporate precum XGBoost, PyTorch, Triton și Hugging Face, precum și modele furnizate de SageMaker JumpStart în puncte finale robuste și scalabile pe SageMaker.

Încurajăm toți utilizatorii SageMaker să încerce această nouă capacitate, referindu-ne la ModelBuilder pagina de documentație. ModelBuilder este disponibil acum pentru toți utilizatorii SageMaker fără costuri suplimentare. Profitați de acest flux de lucru simplificat pentru a vă implementa modelele mai rapid. Așteptăm cu nerăbdare să aflăm cum ModelBuilder vă accelerează ciclul de viață al dezvoltării modelului!

Mulțumiri speciale lui Sirisha Upadhyayala, Raymond Liu, Gary Wang, Dhawal Patel, Deepak Garg și Ram Vegiraju.

Despre autori

Melanie Li, PhD, este TAM Senior AI/ML Specialist la AWS cu sediul în Sydney, Australia. Ea ajută clienții întreprinderilor să construiască soluții folosind instrumente AI/ML de ultimă generație pe AWS și oferă îndrumări privind arhitectura și implementarea soluțiilor ML cu cele mai bune practici. În timpul liber, îi place să exploreze natura și să petreacă timp cu familia și prietenii.

Marc Karp este arhitect ML cu echipa Amazon SageMaker Service. El se concentrează pe a ajuta clienții să proiecteze, să implementeze și să gestioneze sarcinile de lucru ML la scară. În timpul liber, îi place să călătorească și să exploreze locuri noi.

Sam Edwards, este inginer cloud (AI/ML) la AWS Sydney specializat în învățare automată și Amazon SageMaker. Este pasionat de a ajuta clienții să rezolve probleme legate de fluxurile de lucru de învățare automată și de a crea noi soluții pentru ei. În afara serviciului, îi place să joace sporturi cu rachetă și să călătorească.

Raghu Ramesha este arhitect senior de soluții ML cu echipa Amazon SageMaker Service. El se concentrează pe a ajuta clienții să construiască, să implementeze și să migreze sarcinile de lucru de producție ML către SageMaker la scară. El este specializat în domeniile învățarea automată, AI și viziunea pe computer și deține o diplomă de master în Informatică de la UT Dallas. În timpul liber, îi place să călătorească și să fotografieze.

Shiva Raaj Kotini lucrează ca Manager de produs principal în portofoliul de produse de inferență Amazon SageMaker. El se concentrează pe implementarea modelului, reglarea performanței și optimizarea în SageMaker pentru inferență.

Mohan Gandhi este inginer software senior la AWS. El a fost la AWS în ultimii 10 ani și a lucrat la diverse servicii AWS precum EMR, EFA și RDS. În prezent, el se concentrează pe îmbunătățirea experienței de inferință SageMaker. În timpul liber, îi plac drumețiile și maratoanele.

• Distribuție de conținut bazat pe SEO și PR. Amplifică-te astăzi.
• PlatoData.Network Vertical Generative Ai. Împuterniciți-vă. Accesați Aici.
• PlatoAiStream. Web3 Intelligence. Cunoștințe amplificate. Accesați Aici.
• PlatoESG. carbon, CleanTech, Energie, Mediu inconjurator, Solar, Managementul deșeurilor. Accesați Aici.
• PlatoHealth. Biotehnologie și Inteligență pentru studii clinice. Accesați Aici.
• Sursa: https://aws.amazon.com/blogs/machine-learning/package-and-deploy-classical-ml-and-llms-easily-with-amazon-sagemaker-part-1-pysdk-improvements/