Inkrementell träning med Amazon SageMaker JumpStart

Återutgiven av Platon

anhängare: 0

I december 2020, AWS tillkännagav den allmänna tillgängligheten för Amazon SageMaker JumpStart, en förmåga av Amazon SageMaker som hjälper dig att snabbt och enkelt komma igång med maskininlärning (ML). SageMaker JumpStart ger finjustering och distribution med ett klick av ett brett utbud av förutbildade modeller över populära ML-uppgifter, samt ett urval av helhetslösningar som löser vanliga affärsproblem. Dessa funktioner tar bort de tunga lyften från varje steg i ML-processen, vilket gör det lättare att utveckla högkvalitativa modeller och minskar tiden till implementering.

Allt JumpStart-innehåll var tidigare endast tillgängligt via Amazon SageMaker Studio, som ger en användarvänligt grafiskt gränssnitt att interagera med funktionen. Nyligen har vi också meddelade lanseringen av lättanvänd JumpStart API:er som en förlängning av SageMaker Python SDK, så att du kan programmera distribuera och finjustera ett stort urval av JumpStart-stödda förtränade modeller på dina egna datamängder. Den här lanseringen låser upp användningen av JumpStart-funktioner i dina kodarbetsflöden, MLOps-pipelines och överallt där du interagerar med SageMaker via SDK.

I det här inlägget är vi glada att kunna meddela att alla träningsbara JumpStart-modeller nu stöder inkrementell träning. Inkrementell träning låter dig träna en modell som du redan har finjusterat med hjälp av en utökad datauppsättning som innehåller ett underliggande mönster som inte tagits med i tidigare finjusteringskörningar, vilket resulterade i dålig modellprestanda. Inkrementell träning sparar både tid och resurser eftersom du inte behöver träna om modellen från grunden. Om du vill hoppa direkt in i JumpStart API-koden som vi förklarar i det här inlägget, kan du hänvisa till prov anteckningsbok.

JumpStart översikt

JumpStart är en mångfacetterad produkt som innehåller olika funktioner som hjälper dig att snabbt komma igång med ML på SageMaker. I skrivande stund låter JumpStart dig göra följande:

Distribuera förutbildade modeller för vanliga ML-uppgifter – JumpStart gör det möjligt för dig att hantera vanliga ML-uppgifter utan utvecklingsansträngning genom att tillhandahålla enkel distribution av modeller som är förutbildade på stora, allmänt tillgängliga datauppsättningar. ML-forskarsamhället har lagt ner mycket arbete på att göra en majoritet av de nyligen utvecklade modellerna allmänt tillgängliga för användning; JumpStart är värd för en samling av över 300 modeller som spänner över de 15 mest populära ML-uppgifterna som objektdetektering, textklassificering och textgenerering, vilket gör det enkelt för nybörjare att använda dem. Dessa modeller är hämtade från populära modellnav, som TensorFlow, PyTorch, Hugging Face och MXNet Hub.
Finjustera förtränade modeller – JumpStart låter dig finjustera förtränade modeller utan att behöva skriva din egen träningsalgoritm. I ML kallas förmågan att överföra den kunskap som lärts inom en domän till en annan överför lärande. Du kan använda överföringsinlärning för att producera exakta modeller på dina mindre datauppsättningar, med mycket lägre utbildningskostnader än de som är involverade i att träna den ursprungliga modellen. JumpStart inkluderar också populära träningsalgoritmer baserade på LightGBM, CatBoost, XGBoost och Scikit-learn som du kan träna från grunden för tabellregression och klassificering.
Använd färdigbyggda lösningar – JumpStart tillhandahåller en uppsättning av 17 lösningar för vanliga ML-användningsfall som efterfrågeprognoser och industriella och finansiella applikationer, som du kan implementera med bara några klick. Lösningar är end-to-end ML-applikationer som sammanfogar olika AWS-tjänster för att lösa ett visst affärsanvändningsfall. De använder AWS molnformation mallar och referensarkitekturer för snabb implementering, vilket innebär att de är helt anpassningsbara.
Använd exempel på anteckningsbok för SageMaker-algoritmer – SageMaker tillhandahåller en svit med inbyggda algoritmer för att hjälpa datavetare och ML-utövare att snabbt komma igång med utbildning och implementering av ML-modeller. JumpStart tillhandahåller exempel på anteckningsböcker som du kan använda för att snabbt tillämpa dessa algoritmer.
Granska träningsvideor och bloggar – JumpStart tillhandahåller också många blogginlägg och videor som lär dig hur du använder olika funktioner inom SageMaker.

JumpStart accepterar anpassade VPC-inställningar och AWS nyckelhanteringstjänst (AWS KMS) krypteringsnycklar, så att du kan använda de tillgängliga modellerna och lösningarna säkert i din företagsmiljö. Du kan skicka dina säkerhetsinställningar till JumpStart i Studio eller via SageMaker Python SDK.

Bildklassificering

Bildklassificering syftar på att klassificera en bild i en av klassetiketterna i träningsdatauppsättningen. Du kan finjustera modellen till vilken datauppsättning som helst som består av bilder som tillhör valfritt antal klasser. Modellen som är tillgänglig för finjustering på JumpStart fäster ett klassificeringsskikt till motsvarande funktionsextraktionsmodell och initierar skiktparametrarna till slumpmässiga värden. Utmatningsdimensionen för klassificeringsskiktet bestäms baserat på antalet klasser i indata. Finjusteringssteget ställer in klassificeringsskiktets parametrar, samtidigt som parametrarna för funktionsextraktionsmodellen hålls frysta, och returnerar den finjusterade modellen. Målet är att minimera prediktionsfel på indata.

För vår datauppsättning är indata en katalog med lika många underkataloger som antalet klasser. Varje underkatalog bör ha bilder som tillhör den klassen i .jpg-format. Inmatningskatalogen bör se ut som följande hierarki om träningsdata innehåller bilder från två klasser: roses och dandelion:

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

Namnen på mappar, klasser och .jpg-filnamn kan vara vad som helst.

Vi tillhandahåller tf_flowers¹dataset som en standarddatauppsättning för finjustering av modellen. Denna datauppsättning består av bilder av fem typer av blommor. Datauppsättningen har laddats ner från TensorFlow.

Walkthrough-översikt

Följande avsnitt ger en steg-för-steg-demo för att utföra bildklassificering med JumpStart, både via Studio UI och JumpStart API.

Vi går igenom följande steg:

Få åtkomst till JumpStart via Studio UI:
1. Finjustera den förtränade modellen.
2. Implementera den finjusterade modellen.
3. Träna den finjusterade modellen stegvis och distribuera om.
Använd JumpStart programmatiskt med SageMaker Python SDK:
1. Finjustera den förtränade modellen.
2. Implementera den finjusterade modellen.
3. Träna den finjusterade modellen stegvis och distribuera om.

Få åtkomst till JumpStart via Studio UI

I det här avsnittet visar vi hur man finjusterar och distribuerar JumpStart-modeller genom Studio UI. Dessutom visar vi hur man stegvis tränar en modell som du tidigare har finjusterat.

Finjustera den förtränade modellen

Följande video visar hur du hittar en förtränad bildklassificeringsmodell på JumpStart och finjusterar den. Modellsidan innehåller värdefull information om modellen, hur man använder den, förväntat dataformat och några finjusterande detaljer.

För demonstrationsändamål finjusterar vi modellen med hjälp av datamängden som tillhandahålls som standard, vilket är tf_flowers dataset, sammansatt av olika sorter av blommor. Att finjustera din egen datauppsättning innebär att du tar rätt formatering av data (som förklaras på modellsidan), laddar upp den till Amazon enkel lagringstjänst (Amazon S3), och ange dess plats i datakällans konfiguration.

Vi använder samma hyperparametervärden som är inställda som standard (antal epoker, inlärningshastighet och batchstorlek). Vi använder också en GPU-stödd ml.p3.2xlarge-instans som vår SageMaker-utbildningsinstans.

Du kan övervaka ditt träningsjobb direkt på Studio-konsolen och meddelas när det är klart.

Implementera den finjusterade modellen

När utbildningen är klar kan du distribuera den finjusterade modellen från samma sida som innehåller information om utbildningsjobbet. För att distribuera vår modell väljer vi en annan instanstyp, ml.p2.xlarge. Det ger fortfarande GPU-accelerationen som behövs för låg slutledningsfördröjning, men till ett lägre pris. När du har konfigurerat SageMaker-värdinstansen väljer du Distribuera. Det kan ta 5–10 minuter innan ditt ihållande slutpunkt är igång.

Då är din slutpunkt operativ och redo att svara på slutledningsförfrågningar!

För att påskynda din tid till slutledning tillhandahåller JumpStart en exempelanteckningsbok som visar hur du kör inferens på din nyligen distribuerade slutpunkt. Välja Öppna Notebook under Använd Endpoint från Studio.

Träna stegvis upp den finjusterade modellen och implementera

När finjusteringen är klar kan du träna modellen ytterligare för att öka prestandan. Detta steg är mycket likt den initiala finjusteringsprocessen, förutom att vi använder den redan finjusterade modellen som utgångspunkt. Du kan använda nya data, men datauppsättningsformatet måste vara detsamma (samma uppsättning klasser).

Använd JumpStart programmatiskt med SageMaker SDK

I de föregående avsnitten visade vi hur du kan använda JumpStart UI för att finjustera, distribuera och stegvis träna en modell interaktivt med bara några klick. Du kan också använda JumpStarts modeller och enkel finjustering programmatiskt genom att använda API:er som är integrerade i SageMaker SDK. Vi går nu över ett snabbt exempel på hur du kan replikera den föregående processen. Alla steg i denna demo är tillgängliga i de medföljande anteckningsböckerna Introduktion till JumpStart – Bildklassificering.

Finjustera den förtränade modellen

För att finjustera en vald modell måste vi få den modellens URI, såväl som för träningsskriptet och behållarbilden som används för träning. Tack och lov beror dessa tre ingångar enbart på modellnamnet, versionen (för en lista över tillgängliga modeller, se JumpStart Tillgänglig modelltabell), och typ av instans du vill träna på. Detta visas i följande kodavsnitt:

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 hämtar model_id motsvarande samma modell som vi använde tidigare. icen i identifieraren motsvarar bildklassificeringen.

Du kan nu finjustera denna JumpStart-modell på din egen anpassade datauppsättning med SageMaker SDK. Vi använder samma tf_flowers datauppsättning som är offentligt värd på Amazon S3, bekvämt fokuserad på sentimentanalys. Din datauppsättning bör vara strukturerad för finjustering, som förklaras i föregående avsnitt. Se följande exempelkod:

# 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 samma standardhyperparametrar för vår valda modell som de vi såg i föregående avsnitt, med hjälp av sagemaker.hyperparameters.retrieve_default(). Vi instansierar sedan en SageMaker-estimator och anropar .fit-metoden för att börja finjustera vår modell och skickar den till Amazon S3 URI för våra träningsdata. Som du kan se entry_point skriptet som tillhandahålls heter transfer_learning.py (samma för andra uppgifter och modeller), och indatakanalen skickas till .fit måste namnges training.

Utplacering av den finjusterade modellen

När utbildningen är klar kan du distribuera din finjusterade modell. För att göra det behöver vi bara skaffa inferensskriptet URI (koden som bestämmer hur modellen används för slutledning när den väl har distribuerats) och inferensbehållarens bild-URI, som inkluderar en lämplig modellserver för den modell vi valde. Se följande kod:

# 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 några minuter är vår modell utplacerad och vi kan få förutsägelser från den i realtid!

Därefter åberopar vi slutpunkten för att förutsäga vilken typ av blommor som finns i exempelbilden. Vi använder query_endpoint och parse_response hjälparfunktioner, som definieras i den medföljande anteckningsbok.

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äna den finjusterade modellen stegvis och distribuera om

Vi kan öka prestandan hos en finjusterad modell genom att vidareutbilda den på nya bilder. Du kan använda valfritt antal nya eller gamla bilder för detta, men datauppsättningsformatet måste förbli detsamma (samma uppsättning klasser). Det inkrementella träningssteget liknar finjusteringsprocessen, med en viktig skillnad: i den initiala finjusteringen börjar vi med en förtränad modell, medan vi vid inkrementell träning börjar med en befintlig finjusterad modell. Se följande kod:

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 utbildningen är klar kan vi använda samma steg som de som beskrivs i föregående avsnitt för att implementera modellen.

Slutsats

JumpStart är en funktion i SageMaker som gör att du snabbt kan komma igång med ML. JumpStart använder förtränade modeller med öppen källkod för att lösa vanliga ML-problem som bildklassificering, objektdetektering, textklassificering, meningsparklassificering och frågesvar.

I det här inlägget visade vi dig hur du finjusterar och distribuerar en förtränad bildklassificeringsmodell. Vi visade också hur man stegvis tränar en finjusterad modell för bildklassificering. Med JumpStart kan du enkelt utföra denna process utan att behöva koda. Prova lösningen på egen hand och låt oss veta hur det går i kommentarerna. För att lära dig mer om JumpStart, kolla in AWS re:Invent 2020-videon Kom igång med ML på några minuter med Amazon SageMaker JumpStart.

Referensprojekt

TensorFlow-teamet, 2019

Om författarna

Dr. Vivek Madan är en tillämpad forskare med Amazon SageMaker JumpStart-teamet. Han tog sin doktorsexamen. från University of Illinois i Urbana-Champaign och var postdoktor vid Georgia Tech. Han är en aktiv forskare inom maskininlärning och algoritmdesign och har publicerat artiklar i EMNLP-, ICLR-, COLT-, FOCS- och SODA-konferenser.

João Moura är en AI/ML Specialist Solutions Architect på Amazon Web Services. Han är mestadels fokuserad på NLP-användningsfall och att hjälpa kunder att optimera utbildning och implementering av djupinlärningsmodeller. Han är också en aktiv förespråkare för ML-lösningar med låg kod och ML-specialiserad hårdvara.

Dr Ashish Khetan är senior tillämpad forskare med Amazon SageMaker JumpStart och Amazon SageMaker inbyggda algoritmer och hjälper till att utveckla maskininlärningsalgoritmer. Han är en aktiv forskare inom maskininlärning och statistisk slutledning och har publicerat många artiklar i NeurIPS, ICML, ICLR, JMLR, ACL och EMNLP-konferenser.