Inkrementel træning med Amazon SageMaker JumpStart

Genudgivet af Platon

Abonnenter: 0

I december 2020, AWS annoncerede den generelle tilgængelighed af Amazon SageMaker JumpStart, en evne til Amazon SageMaker der hjælper dig hurtigt og nemt at komme i gang med maskinlæring (ML). SageMaker JumpStart giver et-klik finjustering og udrulning af en lang række præ-trænede modeller på tværs af populære ML-opgaver, samt et udvalg af end-to-end-løsninger, der løser almindelige forretningsproblemer. Disse funktioner fjerner de tunge løft fra hvert trin i ML-processen, hvilket gør det nemmere at udvikle højkvalitetsmodeller og reducerer tiden til implementering.

Alt JumpStart-indhold var tidligere kun tilgængeligt via Amazon SageMaker Studio, som giver en brugervenlig grafisk grænseflade at interagere med funktionen. For nylig har vi også annoncerede lanceringen af nem at bruge JumpStart API'er som en udvidelse af SageMaker Python SDK, der giver dig mulighed for programmæssigt at implementere og finjustere et stort udvalg af JumpStart-understøttede præ-trænede modeller på dine egne datasæt. Denne lancering låser op for brugen af JumpStart-funktioner i dine kode-workflows, MLOps-pipelines og alle andre steder, hvor du interagerer med SageMaker via SDK.

I dette indlæg er vi glade for at kunne meddele, at alle trebare JumpStart-modeller nu understøtter inkrementel træning. Inkrementel træning giver dig mulighed for at træne en model, du allerede har finjusteret, ved hjælp af et udvidet datasæt, der indeholder et underliggende mønster, der ikke er taget højde for i tidligere finjusteringskørsler, hvilket resulterede i dårlig modelydelse. Inkrementel træning sparer både tid og ressourcer, fordi du ikke behøver at genoptræne modellen fra bunden. Hvis du vil springe direkte ind i JumpStart API-koden, vi forklarer i dette indlæg, kan du henvise til eksempel notesbog.

JumpStart oversigt

JumpStart er et produkt med mange facetter, der indeholder forskellige muligheder for at hjælpe dig hurtigt i gang med ML på SageMaker. I skrivende stund giver JumpStart dig mulighed for at gøre følgende:

Implementer forudtrænede modeller til almindelige ML-opgaver – JumpStart giver dig mulighed for at løse almindelige ML-opgaver uden udviklingsindsats ved at give nem implementering af modeller, der er forudtrænede på store, offentligt tilgængelige datasæt. ML forskningsmiljøet har lagt en stor indsats i at gøre et flertal af nyligt udviklede modeller offentligt tilgængelige til brug; JumpStart er vært for en samling af over 300 modeller, der spænder over de 15 mest populære ML-opgaver såsom objektgenkendelse, tekstklassificering og tekstgenerering, hvilket gør det nemt for begyndere at bruge dem. Disse modeller er hentet fra populære modelhubs, såsom TensorFlow, PyTorch, Hugging Face og MXNet Hub.
Finjuster fortrænede modeller – JumpStart giver dig mulighed for at finjustere fortrænede modeller uden at skulle skrive din egen træningsalgoritme. I ML kaldes evnen til at overføre den lærte viden i et domæne til et andet overføre læring. Du kan bruge transfer learning til at producere nøjagtige modeller på dine mindre datasæt med meget lavere uddannelsesomkostninger end dem, der er involveret i træning af den originale model. JumpStart inkluderer også populære træningsalgoritmer baseret på LightGBM, CatBoost, XGBoost og Scikit-learn, som du kan træne fra bunden til tabelregression og klassificering.
Brug færdigbyggede løsninger – JumpStart leverer et sæt af 17 løsninger til almindelige ML-brugssager såsom behovsprognose og industrielle og finansielle applikationer, som du kan implementere med blot et par klik. Løsninger er end-to-end ML-applikationer, der samler forskellige AWS-tjenester for at løse en bestemt forretningsbrugssag. De bruger AWS CloudFormation skabeloner og referencearkitekturer til hurtig implementering, hvilket betyder, at de kan tilpasses fuldt ud.
Brug notesbogseksempler til SageMaker-algoritmer – SageMaker leverer en suite af indbyggede algoritmer til at hjælpe dataforskere og ML-praktikere hurtigt i gang med træning og implementering af ML-modeller. JumpStart giver eksempler på notesbøger, som du kan bruge til hurtigt at anvende disse algoritmer.
Gennemgå træningsvideoer og blogs – JumpStart giver også adskillige blogindlæg og videoer, der lærer dig, hvordan du bruger forskellige funktioner i SageMaker.

JumpStart accepterer brugerdefinerede VPC-indstillinger og AWS Key Management Service (AWS KMS) krypteringsnøgler, så du kan bruge de tilgængelige modeller og løsninger sikkert i dit virksomhedsmiljø. Du kan videregive dine sikkerhedsindstillinger til JumpStart i Studio eller gennem SageMaker Python SDK.

Billedklassificering

Billedklassificering refererer til klassificering af et billede i en af klasseetiketterne i træningsdatasættet. Du kan finjustere modellen til et givet datasæt, der omfatter billeder, der tilhører et vilkårligt antal klasser. Den model, der er tilgængelig til finjustering på JumpStart, knytter et klassifikationslag til den tilsvarende funktionsudtræksmodel og initialiserer lagparametrene til tilfældige værdier. Klassifikationslagets outputdimension bestemmes ud fra antallet af klasser i inputdataene. Finjusteringstrinnet tuner klassifikationslagets parametre, mens parametrene for feature extractor-modellen holdes frosset, og returnerer den finjusterede model. Målet er at minimere forudsigelsesfejl på inputdata.

For vores datasæt er input en mappe med lige så mange undermapper som antallet af klasser. Hver undermappe skal have billeder tilhørende den pågældende klasse i .jpg-format. Indtastningsmappen skal se ud som følgende hierarki, hvis træningsdataene indeholder billeder fra to klasser: roses , dandelion:

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

Navnene på mapperne, klasserne og .jpg-filnavnene kan være hvad som helst.

Vi leverer tf_flowers¹datasæt som et standarddatasæt til finjustering af modellen. Dette datasæt består af billeder af fem typer blomster. Datasættet er blevet downloadet fra TensorFlow.

Gennemgangsoversigt

De følgende afsnit giver en trin-for-trin demo til at udføre billedklassificering med JumpStart, både via Studio UI og JumpStart API'er.

Vi gennemgår følgende trin:

Få adgang til JumpStart gennem Studio UI:
1. Finjuster den fortrænede model.
2. Implementer den finjusterede model.
3. Træn den finjusterede model trinvist og geninstaller.
Brug JumpStart programmatisk med SageMaker Python SDK:
1. Finjuster den fortrænede model.
2. Implementer den finjusterede model.
3. Træn den finjusterede model trinvist og geninstaller.

Få adgang til JumpStart gennem Studio UI

I dette afsnit demonstrerer vi, hvordan man finjusterer og implementerer JumpStart-modeller gennem Studio UI. Derudover viser vi, hvordan man trinvist træner en model, som du tidligere har finjusteret.

Finjuster den fortrænede model

Den følgende video viser dig, hvordan du finder en forudtrænet billedklassificeringsmodel på JumpStart og finjusterer den. Modelsiden indeholder værdifuld information om modellen, hvordan den bruges, forventet dataformat og nogle finjusteringsdetaljer.

Til demonstrationsformål finjusterer vi modellen ved hjælp af det datasæt, der leveres som standard, som er tf_flowers datasæt, sammensat af forskellige sorter af blomster. Finjustering af dit eget datasæt involverer at tage den korrekte formatering af data (som forklaret på modelsiden), uploade dem til Amazon Simple Storage Service (Amazon S3), og angivelse af dens placering i datakildekonfigurationen.

Vi bruger de samme hyperparameterværdier, der er angivet som standard (antal epoker, indlæringshastighed og batchstørrelse). Vi bruger også en GPU-støttet ml.p3.2xlarge-instans som vores SageMaker-træningsinstans.

Du kan overvåge dit træningsjob direkte på Studio-konsollen og får besked, når det er afsluttet.

Implementer den finjusterede model

Når træningen er fuldført, kan du implementere den finjusterede model fra den samme side, som indeholder oplysningerne om træningsjob. For at implementere vores model vælger vi en anden instanstype, ml.p2.xlarge. Det giver stadig den GPU-acceleration, der er nødvendig for lav slutningsforsinkelse, men til et lavere prispunkt. Når du har konfigureret SageMaker-hostingforekomsten, skal du vælge Implementer. Det kan tage 5-10 minutter, før dit vedvarende endepunkt er oppe at køre.

Så er dit slutpunkt operationelt og klar til at svare på anmodninger om slutninger!

For at fremskynde din tid til inferens, giver JumpStart en eksempelnotesbog, der viser dig, hvordan du kører inferens på dit nyligt implementerede slutpunkt. Vælge Åbn Notesbog under Brug slutpunkt fra Studio.

Træn gradvist den finjusterede model og implementer

Når finjusteringen er færdig, kan du træne modellen yderligere for at øge ydeevnen. Dette trin minder meget om den indledende finjusteringsproces, bortset fra at vi bruger den allerede finjusterede model som udgangspunkt. Du kan bruge nye data, men datasætformatet skal være det samme (samme sæt klasser).

Brug JumpStart programmatisk med SageMaker SDK

I de foregående afsnit viste vi, hvordan du kan bruge JumpStart UI til at finjustere, implementere og trinvist træne en model interaktivt med få klik. Du kan også bruge JumpStarts modeller og nem finjustering programmatisk ved at bruge API'er, der er integreret i SageMaker SDK. Vi gennemgår nu et hurtigt eksempel på, hvordan du kan kopiere den foregående proces. Alle trinene i denne demo er tilgængelige i de medfølgende notesbøger Introduktion til JumpStart – Billedklassificering.

Finjuster den fortrænede model

For at finjustere en udvalgt model skal vi få den models URI, såvel som for træningsscriptet og containerbilledet, der bruges til træning. Heldigvis afhænger disse tre input udelukkende af modelnavnet, versionen (for en liste over tilgængelige modeller, se JumpStart tilgængelig model tabel), og type instans, du vil træne på. Dette er demonstreret i følgende kodestykke:

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 svarende til den samme model, som vi brugte tidligere. Ic'en i identifikatoren svarer til billedklassificering.

Du kan nu finjustere denne JumpStart-model på dit eget brugerdefinerede datasæt ved hjælp af SageMaker SDK. Vi bruger det samme tf_flowers datasæt, der er offentligt hostet på Amazon S3, bekvemt fokuseret på sentimentanalyse. Dit datasæt skal være struktureret til finjustering, som forklaret i det foregående afsnit. 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 opnår de samme standard hyperparametre for vores valgte model som dem, vi så i det foregående afsnit, vha sagemaker.hyperparameters.retrieve_default(). Vi instansierer derefter en SageMaker-estimator og kalder .fit-metoden for at begynde at finjustere vores model og videregive den til Amazon S3 URI for vores træningsdata. Som du kan se, er entry_point det angivne script er navngivet transfer_learning.py (det samme for andre opgaver og modeller), og inputdatakanalen videregivet til .fit skal navngives training.

Implementering af den finjusterede model

Når træningen er færdig, kan du implementere din finjusterede model. For at gøre det, er alt, hvad vi behøver at opnå, inferensscript-URI (koden, der bestemmer, hvordan modellen bruges til inferens, når den først er installeret) og inferenscontainerbillede-URI, som inkluderer en passende modelserver til at være vært for den model, 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,
)

Efter et par minutter er vores model implementeret, og vi kan få forudsigelser fra den i realtid!

Dernæst påberåber vi endepunktet for at forudsige, hvilken type blomster der findes i eksempelbilledet. Vi bruger query_endpoint , parse_response hjælpefunktioner, som er defineret i den medfølgende notesbog.

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

Træn den finjusterede model trinvist og geninstaller

Vi kan øge ydeevnen af en finjusteret model ved at træne den videre på nye billeder. Du kan bruge et hvilket som helst antal nye eller gamle billeder til dette, dog skal datasættets format forblive det samme (samme sæt klasser). Det trinvise træningstrin ligner finjusteringsprocessen, med en vigtig forskel: I den indledende finjustering starter vi med en fortrænet model, hvorimod vi ved trinvis træning starter med en eksisterende finjusteret model. 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 træningen er færdig, kan vi bruge de samme trin som dem, der er beskrevet i det foregående afsnit, til at implementere modellen.

Konklusion

JumpStart er en funktion i SageMaker, der giver dig mulighed for hurtigt at komme i gang med ML. JumpStart bruger open source præ-trænede modeller til at løse almindelige ML-problemer som billedklassificering, objektgenkendelse, tekstklassificering, sætningsparklassificering og besvarelse af spørgsmål.

I dette indlæg viste vi dig, hvordan du finjusterer og implementerer en forudtrænet billedklassificeringsmodel. Vi viste også, hvordan man trinvist træner en finjusteret model til billedklassificering. Med JumpStart kan du nemt udføre denne proces uden at skulle kode. Prøv løsningen på egen hånd, og lad os vide, hvordan det går i kommentarerne. For at lære mere om JumpStart, tjek AWS re:Invent 2020-videoen Kom godt i gang med ML på få minutter med Amazon SageMaker JumpStart.

Referencer

TensorFlow-teamet, 2019

Om forfatterne

Dr. Vivek Madan er en anvendt videnskabsmand hos Amazon SageMaker JumpStart-teamet. Han fik sin ph.d. fra University of Illinois i Urbana-Champaign og var Post Doctoral Researcher ved Georgia Tech. Han er en aktiv forsker i maskinlæring og algoritmedesign og har publiceret artikler i EMNLP, ICLR, COLT, FOCS og SODA konferencer.

João Moura er AI/ML Specialist Solutions Architect hos Amazon Web Services. Han er for det meste fokuseret på NLP-brugscases og hjælper kunder med at optimere træning og implementering af deep learning-modeller. Han er også en aktiv fortaler for lavkode ML-løsninger og ML-specialiseret hardware.

Dr. Ashish Khetan er Senior Applied Scientist med Amazon SageMaker JumpStart , Amazon SageMaker indbyggede algoritmer og hjælper med at udvikle maskinlæringsalgoritmer. Han er en aktiv forsker i maskinlæring og statistisk inferens og har publiceret mange artikler i NeurIPS, ICML, ICLR, JMLR, ACL og EMNLP konferencer.