Inkrementell trening med Amazon SageMaker JumpStart

Publisert av Platon

Følgere: 0

I desember 2020, AWS kunngjorde den generelle tilgjengeligheten av Amazon SageMaker JumpStart, en evne til Amazon SageMaker som hjelper deg raskt og enkelt å komme i gang med maskinlæring (ML). SageMaker JumpStart gir ett-klikks finjustering og distribusjon av et bredt utvalg av forhåndstrente modeller på tvers av populære ML-oppgaver, samt et utvalg ende-til-ende-løsninger som løser vanlige forretningsproblemer. Disse funksjonene fjerner de tunge løftene fra hvert trinn i ML-prosessen, noe som gjør det enklere å utvikle høykvalitetsmodeller og reduserer tiden til utrulling.

Alt JumpStart-innhold var tidligere kun tilgjengelig via Amazon SageMaker Studio, som gir en brukervennlig grafisk grensesnitt for å samhandle med funksjonen. Nylig har vi også annonserte lanseringen av enkel å bruke JumpStart APIer som en utvidelse av SageMaker Python SDK, som lar deg programmere distribuere og finjustere et stort utvalg av JumpStart-støttede forhåndstrente modeller på dine egne datasett. Denne lanseringen låser opp bruken av JumpStart-funksjoner i kodearbeidsflytene dine, MLOps-pipelines og andre steder du samhandler med SageMaker via SDK.

I dette innlegget er vi glade for å kunngjøre at alle trenbare JumpStart-modeller nå støtter inkrementell trening. Inkrementell trening lar deg trene en modell du allerede har finjustert ved å bruke et utvidet datasett som inneholder et underliggende mønster som ikke er tatt med i tidligere finjusteringskjøringer, noe som resulterte i dårlig modellytelse. Inkrementell trening sparer både tid og ressurser fordi du ikke trenger å trene opp modellen fra bunnen av. Hvis du vil hoppe rett inn i JumpStart API-koden vi forklarer i dette innlegget, kan du referere til prøve notatbok.

JumpStart oversikt

JumpStart er et mangefasettert produkt som inkluderer forskjellige funksjoner for å hjelpe deg raskt i gang med ML på SageMaker. I skrivende stund lar JumpStart deg gjøre følgende:

Distribuer forhåndstrente modeller for vanlige ML-oppgaver – JumpStart lar deg løse vanlige ML-oppgaver uten utviklingsinnsats ved å tilby enkel distribusjon av modeller som er forhåndsopplært på store, offentlig tilgjengelige datasett. ML-forskningsmiljøet har lagt ned en stor innsats for å gjøre et flertall av nylig utviklede modeller offentlig tilgjengelig for bruk; JumpStart er vert for en samling på over 300 modeller, som spenner over de 15 mest populære ML-oppgavene som objektgjenkjenning, tekstklassifisering og tekstgenerering, noe som gjør det enkelt for nybegynnere å bruke dem. Disse modellene er hentet fra populære modellhuber, som TensorFlow, PyTorch, Hugging Face og MXNet Hub.
Finjuster forhåndstrente modeller – JumpStart lar deg finjustere ferdigtrente modeller uten å måtte skrive din egen treningsalgoritme. I ML kalles evnen til å overføre kunnskapen lært i ett domene til et annet overføre læring. Du kan bruke overføringslæring til å produsere nøyaktige modeller på de mindre datasettene dine, med mye lavere opplæringskostnader enn de som er involvert i opplæringen av den originale modellen. JumpStart inkluderer også populære treningsalgoritmer basert på LightGBM, CatBoost, XGBoost og Scikit-learn som du kan trene fra bunnen av for tabellregresjon og klassifisering.
Bruk forhåndsbygde løsninger – JumpStart tilbyr et sett med 17 løsninger for vanlige ML-brukstilfeller som etterspørselsprognoser og industrielle og finansielle applikasjoner, som du kan implementere med bare noen få klikk. Løsninger er ende-til-ende ML-applikasjoner som setter sammen ulike AWS-tjenester for å løse et bestemt forretningsbruk. De bruker AWS skyformasjon maler og referansearkitekturer for rask distribusjon, noe som betyr at de er fullt tilpassbare.
Bruk bærbare eksempler for SageMaker-algoritmer – SageMaker tilbyr en pakke med innebygde algoritmer for å hjelpe dataforskere og ML-utøvere raskt i gang med opplæring og distribusjon av ML-modeller. JumpStart gir eksempler på notatbøker som du kan bruke til å raskt bruke disse algoritmene.
Gjennomgå treningsvideoer og blogger – JumpStart gir også en rekke blogginnlegg og videoer som lærer deg hvordan du bruker forskjellige funksjoner i SageMaker.

JumpStart godtar tilpassede VPC-innstillinger og AWS nøkkelstyringstjeneste (AWS KMS) krypteringsnøkler, slik at du kan bruke de tilgjengelige modellene og løsningene sikkert i bedriftsmiljøet ditt. Du kan sende sikkerhetsinnstillingene til JumpStart i Studio eller gjennom SageMaker Python SDK.

Bildeklassifisering

Bildeklassifisering refererer til å klassifisere et bilde i en av klasseetikettene i opplæringsdatasettet. Du kan finjustere modellen til et gitt datasett som består av bilder som tilhører et hvilket som helst antall klasser. Modellen som er tilgjengelig for finjustering på JumpStart, knytter et klassifiseringslag til den tilsvarende funksjonsuttrekksmodellen og initialiserer lagparametrene til tilfeldige verdier. Utgangsdimensjonen til klassifiseringslaget bestemmes basert på antall klasser i inngangsdataene. Finjusteringstrinnet stiller inn klassifiseringslagets parametere, mens parametrene til funksjonsuttrekksmodellen holdes frosset, og returnerer den finjusterte modellen. Målet er å minimere prediksjonsfeil på inndataene.

For vårt datasett er inngangen en katalog med like mange underkataloger som antall klasser. Hver underkatalog skal ha bilder som tilhører den klassen i .jpg-format. Inndatakatalogen skal se ut som følgende hierarki hvis treningsdataene inneholder bilder fra to klasser: roses og dandelion:

input_directory |--roses |--abc.jpg |--def.jpg |--dandelion |--ghi.jpg |--jkl.jpg

Navnene på mappene, klassene og .jpg-filnavnene kan være hva som helst.

Vi tilbyr tf_flowers¹datasett som standard datasett for finjustering av modellen. Dette datasettet består av bilder av fem typer blomster. Datasettet er lastet ned fra tensorflow.

Gjennomgangsoversikt

De følgende delene gir en trinn-for-trinn-demo for å utføre bildeklassifisering med JumpStart, både via Studio UI og JumpStart APIer.

Vi går gjennom følgende trinn:

Få tilgang til JumpStart gjennom Studio UI:
1. Finjuster den ferdigtrente modellen.
2. Implementer den finjusterte modellen.
3. Tren opp den finjusterte modellen trinnvis og omplasser.
Bruk JumpStart programmatisk med SageMaker Python SDK:
1. Finjuster den ferdigtrente modellen.
2. Implementer den finjusterte modellen.
3. Tren opp den finjusterte modellen trinnvis og omplasser.

Få tilgang til JumpStart gjennom Studio UI

I denne delen viser vi hvordan du finjusterer og distribuerer JumpStart-modeller gjennom Studio UI. I tillegg viser vi hvordan du trinnvis trener en modell som du tidligere har finjustert.

Finjuster den ferdigtrente modellen

Følgende video viser deg hvordan du finner en forhåndsopplært bildeklassifiseringsmodell på JumpStart og finjusterer den. Modellsiden inneholder verdifull informasjon om modellen, hvordan du bruker den, forventet dataformat og noen finjusteringsdetaljer.

For demonstrasjonsformål finjusterer vi modellen ved å bruke datasettet som leveres som standard, som er tf_flowers datasett, sammensatt av forskjellige varianter av blomster. Finjustering av ditt eget datasett innebærer å ta riktig formatering av data (som forklart på modellsiden), laste det opp til Amazon enkel lagringstjeneste (Amazon S3), og spesifisere plasseringen i datakildekonfigurasjonen.

Vi bruker de samme hyperparameterverdiene som er satt som standard (antall epoker, læringshastighet og batchstørrelse). Vi bruker også en GPU-støttet ml.p3.2xlarge-instans som vår SageMaker-treningsinstans.

Du kan overvåke treningsjobben din direkte på Studio-konsollen, og blir varslet når den er fullført.

Implementer den finjusterte modellen

Etter at opplæringen er fullført, kan du distribuere den finjusterte modellen fra samme side som inneholder treningsjobbdetaljene. For å distribuere modellen vår velger vi en annen forekomsttype, ml.p2.xlarge. Det gir fortsatt GPU-akselerasjonen som trengs for lav slutningsforsinkelse, men til et lavere prispunkt. Etter at du har konfigurert SageMaker-vertsinstansen, velger du Distribuer. Det kan ta 5–10 minutter før det vedvarende endepunktet ditt er oppe og går.

Da er endepunktet ditt operativt og klart til å svare på slutningsforespørsler!

For å akselerere tiden din til inferens gir JumpStart en eksempelnotisbok som viser deg hvordan du kjører inferens på det nylig distribuerte endepunktet. Velge Åpne Notebook etter Bruk endepunkt fra Studio.

Tren den finjusterte modellen trinnvis og distribuer

Når finjusteringen er fullført, kan du trene modellen videre for å øke ytelsen. Dette trinnet er veldig likt den innledende finjusteringsprosessen, bortsett fra at vi bruker den allerede finjusterte modellen som utgangspunkt. Du kan bruke nye data, men datasettformatet må være det samme (samme sett med klasser).

Bruk JumpStart programmatisk med SageMaker SDK

I de foregående delene viste vi hvordan du kan bruke JumpStart UI til å finjustere, distribuere og trinnvis trene en modell interaktivt i løpet av noen få klikk. Du kan også bruke JumpStarts modeller og enkel finjustering programmatisk ved å bruke APIer som er integrert i SageMaker SDK. Vi går nå over et raskt eksempel på hvordan du kan replikere den foregående prosessen. Alle trinnene i denne demoen er tilgjengelige i de medfølgende notatbøkene Introduksjon til JumpStart – Bildeklassifisering.

Finjuster den ferdigtrente modellen

For å finjustere en valgt modell, må vi få den modellens URI, samt den til treningsskriptet og beholderbildet som brukes til opplæring. Heldigvis avhenger disse tre inngangene utelukkende av modellnavnet, versjonen (for en liste over tilgjengelige modeller, se JumpStart tilgjengelig modellbord), og type instans du vil trene på. Dette er demonstrert i følgende kodebit:

from sagemaker import image_uris, model_uris, script_uris model_id, model_version = "pytorch-ic-mobilenet-v2", "1.0.0"
training_instance_type = "ml.p3.2xlarge" # Retrieve the docker image
train_image_uri = image_uris.retrieve( region=None, framework=None, model_id=model_id, model_version=model_version, image_scope="training", instance_type=training_instance_type,
) # Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training") # Retrieve the pre-trained model tarball to further fine-tune
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

Vi henter model_id tilsvarende den samme modellen vi brukte tidligere. Ic-en i identifikatoren tilsvarer bildeklassifiseringen.

Du kan nå finjustere denne JumpStart-modellen på ditt eget tilpassede datasett ved å bruke SageMaker SDK. Vi bruker det samme tf_flowers datasett som er offentlig hostet på Amazon S3, praktisk fokusert på sentimentanalyse. Datasettet ditt bør være strukturert for finjustering, som forklart i forrige avsnitt. Se følgende eksempelkode:

# URI of your training dataset
training_dataset_s3_path = "s3://jumpstart-cache-prod-us-west-2/training-datasets/tf_flowers/"
training_job_name = name_from_base(f"jumpstart-example-{model_id}-transfer-learning") # Create SageMaker Estimator instance
ic_estimator = Estimator( role=aws_role, image_uri=train_image_uri, source_dir=train_source_uri, model_uri=train_model_uri, entry_point="transfer_learning.py", instance_count=1, instance_type=training_instance_type, max_run=360000, hyperparameters=hyperparameters, output_path=s3_output_location,
) # Launch a SageMaker Training job by passing s3 path of the training data
ic_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Vi får de samme standard hyperparametrene for den valgte modellen som de vi så i forrige seksjon ved å bruke sagemaker.hyperparameters.retrieve_default(). Vi instansierer deretter en SageMaker-estimator og kaller .fit-metoden for å begynne å finjustere modellen vår, og gir den Amazon S3 URI for treningsdataene våre. Som du kan se, er entry_point skriptet som er gitt er navngitt transfer_learning.py (det samme for andre oppgaver og modeller), og inngangsdatakanalen sendt til .fit må navngis training.

Utplassering av den finjusterte modellen

Når opplæringen er fullført, kan du distribuere den finjusterte modellen. For å gjøre det, er alt vi trenger å få tak i inferensskriptet URI (koden som bestemmer hvordan modellen brukes for inferens når den er distribuert) og inferensbeholderbildet URI, som inkluderer en passende modellserver for å være vert for modellen vi valgte. Se følgende kode:

# Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve( region=None, framework=None, image_scope="inference", model_id=model_id, model_version=model_version, instance_type=inference_instance_type,
)
# Retrieve the inference script uri
deploy_source_uri = script_uris.retrieve( model_id=model_id, model_version=model_version, script_scope="inference"
) endpoint_name = name_from_base(f"jumpstart-example-FT-{model_id}-") # Use the estimator from the previous step to deploy to a SageMaker endpoint
finetuned_predictor = ic_estimator.deploy( initial_instance_count=1, instance_type=inference_instance_type, entry_point="inference.py", image_uri=deploy_image_uri, source_dir=deploy_source_uri, endpoint_name=endpoint_name,
)

Etter noen minutter er modellen vår distribuert og vi kan få spådommer fra den i sanntid!

Deretter påkaller vi endepunktet for å forutsi hvilken type blomster som finnes i eksempelbildet. Vi bruker query_endpoint og parse_response hjelpefunksjoner, som er definert i den medfølgende bærbare.

query_response = finetuned_predictor.predict( img, {"ContentType": "application/x-image", "Accept": "application/json;verbose"} )
model_predictions = json.loads(query_response)
predicted_label = model_predictions["predicted_label"]
display( HTML( f'<img src={image_filename} alt={image_filename} align="left" style="width: 250px;"/>' f"<figcaption>Predicted Label: {predicted_label}</figcaption>" )
)

Tren opp den finjusterte modellen trinnvis og omplasser

Vi kan øke ytelsen til en finjustert modell ved å trene den videre på nye bilder. Du kan bruke et hvilket som helst antall nye eller gamle bilder til dette, men datasettformatet må forbli det samme (samme sett med klasser). Det inkrementelle treningstrinnet ligner på finjusteringsprosessen, med en viktig forskjell: i den innledende finjusteringen starter vi med en forhåndstrent modell, mens vi i inkrementell trening starter med en eksisterende finjustert modell. Se følgende kode:

last_trained_model_path = f"{s3_output_location}/{last_training_job_name}/output/model.tar.gz"
incremental_s3_output_location = f"s3://{output_bucket}/{incremental_output_prefix}/output"incremental_train_estimator = Estimator( role=aws_role, image_uri=train_image_uri, source_dir=train_source_uri, model_uri=last_trained_model_path, entry_point="transfer_learning.py", instance_count=1, instance_type=training_instance_type, max_run=360000, hyperparameters=hyperparameters, output_path=incremental_s3_output_location, base_job_name=incremental_training_job_name,
) incremental_train_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Når opplæringen er fullført, kan vi bruke de samme trinnene som de som er beskrevet i den foregående delen for å distribuere modellen.

konklusjonen

JumpStart er en funksjon i SageMaker som lar deg raskt komme i gang med ML. JumpStart bruker åpen kildekode forhåndstrente modeller for å løse vanlige ML-problemer som bildeklassifisering, objektgjenkjenning, tekstklassifisering, setningsparklassifisering og spørsmålssvar.

I dette innlegget viste vi deg hvordan du finjusterer og distribuerer en forhåndsopplært bildeklassifiseringsmodell. Vi viste også hvordan man trinnvis trener en finjustert modell for bildeklassifisering. Med JumpStart kan du enkelt utføre denne prosessen uten å måtte kode. Prøv løsningen på egen hånd og la oss få vite hvordan det går i kommentarfeltet. For å lære mer om JumpStart, sjekk ut AWS re:Invent 2020-videoen Kom i gang med ML på få minutter med Amazon SageMaker JumpStart.

Referanser

TensorFlow-teamet, 2019

Om forfatterne

Dr. Vivek Madan er en Applied Scientist med Amazon SageMaker JumpStart-teamet. Han fikk sin doktorgrad. fra University of Illinois i Urbana-Champaign og var postdoktor ved Georgia Tech. Han er en aktiv forsker innen maskinlæring og algoritmedesign og har publisert artikler på EMNLP-, ICLR-, COLT-, FOCS- og SODA-konferanser.

João Moura er en AI/ML-spesialistløsningsarkitekt hos Amazon Web Services. Han er mest fokusert på NLP-brukstilfeller og å hjelpe kunder med å optimalisere opplæring og implementering av dyplæringsmodeller. Han er også en aktiv talsmann for lavkode ML-løsninger og ML-spesialisert maskinvare.

Dr. Ashish Khetan er Senior Applied Scientist med Amazon SageMaker JumpStart og Amazon SageMaker innebygde algoritmer og hjelper til med å utvikle maskinlæringsalgoritmer. Han er en aktiv forsker innen maskinlæring og statistisk inferens og har publisert mange artikler i NeurIPS, ICML, ICLR, JMLR, ACL og EMNLP-konferanser.