Kör bildsegmentering med Amazon SageMaker JumpStart

I december 2020, AWS meddelade den allmänna tillgängligheten till 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). JumpStart tillhandahåller finjustering och distribution med ett klick av en mängd olika förtränade 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.

Det här inlägget är det tredje i en serie om att använda JumpStart för specifika ML-uppgifter. I den första inlägget, visade vi hur du kan köra användningsfall för bildklassificering på JumpStart. I den andra inlägget, visade vi hur du kan köra användningsfall för textklassificering på JumpStart. I det här inlägget ger vi en steg-för-steg-genomgång om hur man finjusterar och distribuerar en bildsegmenteringsmodell med hjälp av utbildade modeller från MXNet. Vi utforskar två sätt att få samma resultat: via JumpStarts grafiska gränssnitt på Amazon SageMaker Studio, och programmatiskt igenom JumpStart API:er.

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 följande exempel på Jupyter-anteckningsböcker:

JumpStart översikt

JumpStart hjälper dig att komma igång med ML-modeller för en mängd olika uppgifter utan att skriva en enda rad kod. I skrivande stund låter JumpStart dig göra följande:

• Distribuera förutbildade modeller för vanliga ML-uppgifter – JumpStart gör att du kan 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.
• 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 i en domän till en annan domän ö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 innehåller 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, så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.
• Se exempel på anteckningsboken 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 använda 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.

Semantisk segmentering

Semantisk segmentering avgränsar varje klass av objekt som visas i en ingångsbild. Den taggar (klassificerar) varje pixel i inmatningsbilden med en klassetikett från en fördefinierad uppsättning klasser. Flera objekt av samma klass mappas till samma mask.

Modellen som är tillgänglig för finjustering bygger ett helt faltningsnätverk (FCN) "huvud" ovanpå basnätverket. Finjusteringssteget finjusterar FCNHead samtidigt som parametrarna för resten av modellen fryst, och returnerar den finjusterade modellen. Målet är att minimera softmax korsentropiförlusten per pixel för att träna FCN. Modellen som returneras genom finjustering kan vidareutvecklas för slutledning.

Inmatningskatalogen bör se ut som följande kod om träningsdata innehåller två bilder. Namnen på .png-filerna kan vara vad som helst.

input_directory
    |--images
        |--abc.png
        |--def.png
    |--masks
        |--abc.png
        |--def.png
    class_label_to_prediction_index.json

Maskfilerna bör ha klassetikettinformation för varje pixel.

Instanssegmentering

Instanssegmentering upptäcker och avgränsar varje distinkt föremål av intresse som visas i en bild. Den taggar varje pixel med en instansetikett. Medan semantisk segmentering tilldelar samma tagg till pixlar av flera objekt av samma klass, etiketterar instanssegmentering ytterligare pixlar som motsvarar varje förekomst av ett objekt på bilden med en separat tagg.

För närvarande erbjuder JumpStart modeller endast för slutledning till exempel segmentering och stöder inte finjustering.

Följande bilder illustrerar skillnaden mellan inferensen i semantisk segmentering och instanssegmentering. Originalbilden har två personer i bilden. Semantisk segmentering behandlar flera personer i bilden som en enhet: Person. Emellertid identifierar instanssegmentering enskilda personer inom Person kategori.

Lösningsöversikt

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

Vi går igenom följande steg:

1. Få åtkomst till JumpStart via Studio UI:
   1. Kör slutledning på den förtränade modellen.
   2. Finjustera den förtränade modellen.
2. Använd JumpStart programmatiskt med SageMaker Python SDK:
   1. Kör slutledning på den förtränade modellen.
   2. Finjustera den förtränade modellen.

Vi diskuterar även ytterligare avancerade funktioner i JumpStart.

Få åtkomst till JumpStart via Studio UI

I det här avsnittet visar vi hur man tränar och distribuerar JumpStart-modeller genom Studio UI.

Kör slutledning på den förtränade modellen

Följande video visar hur du hittar en förtränad semantisk segmenteringsmodell på JumpStart och distribuerar den. Modellsidan innehåller värdefull information om modellen, hur man använder den, förväntat dataformat och några finjusteringsdetaljer. Du kan distribuera vilken som helst av de förtränade modellerna som finns tillgängliga i JumpStart. Som slutledning väljer vi instanstypen ml.g4dn.xlarge. Det ger den GPU-acceleration 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.

Efter några minuter är din slutpunkt operativ och redo att svara på slutledningsförfrågningar.

På samma sätt kan du distribuera en förtränad instanssegmenteringsmodell genom att följa samma steg i föregående video medan du söker efter t.ex. segmentering istället för semantisk segmentering i JumpStart-sökfältet.

Finjustera den förtränade modellen

Följande video visar hur du hittar och finjusterar en semantisk segmenteringsmodell i JumpStart. I videon finjusterar vi modellen med hjälp av PennFudanPed dataset, tillhandahålls som standard i JumpStart, som du kan ladda ner under Apache 2.0-licens.

Finjustering av 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 som vår SageMaker-utbildningsinstans.

Du kan övervaka ditt träningsjobb som körs direkt på Studio-konsolen och får ett meddelande när det är klart. När utbildningen är klar kan du distribuera den finjusterade modellen från samma sida som innehåller information om utbildningsjobbet. Implementeringsarbetsflödet är detsamma som att implementera en förutbildad modell.

Använd JumpStart programmatiskt med SageMaker SDK

I de föregående avsnitten visade vi hur du kan använda JumpStart-gränssnittet för att distribuera en förtränad modell och finjustera den interaktivt, med bara några få klick. Du kan dock 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 – Instanssegmentering och Introduktion till JumpStart – Semantisk segmentering.

Kör slutledning på den förtränade modellen

I det här avsnittet väljer vi en lämplig förtränad modell i JumpStart, distribuerar denna modell till en SageMaker-slutpunkt och kör slutledning om den distribuerade slutpunkten.

SageMaker är en plattform baserad på Docker-containrar. JumpStart använder den tillgängliga ramspecifika SageMaker Deep Learning Containers (DLC). Vi hämtar eventuella ytterligare paket, samt skript för att hantera utbildning och slutledning för den valda uppgiften. Slutligen hämtas de förtränade modellartefakterna separat med model_uris, vilket ger flexibilitet till plattformen. Du kan använda valfritt antal modeller som är förutbildade för samma uppgift med ett enda tränings- eller slutledningsskript. Se följande kod:

model_id, model_version = "mxnet-semseg-fcn-resnet50-ade", "*"

# Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve(
    region=None,
    framework=None,  # automatically inferred from model_id
    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")

base_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="inference")

Till exempel segmentering kan vi ställa in model_id till mxnet-semseg-fcn-resnet50-ade. Det är i identifieraren motsvarar instanssegmentering.

Därefter matar vi resurserna till en SageMaker modell instans och distribuera en slutpunkt:

# Create the SageMaker model instance
model = Model(
    image_uri=deploy_image_uri,
    source_dir=deploy_source_uri,
    model_data=base_model_uri,
    entry_point="inference.py",  # entry point file in source_dir and present in deploy_source_uri
    role=aws_role,
    predictor_cls=Predictor,
    name=endpoint_name,
)

# deploy the Model. Note that we need to pass Predictor class when we deploy model through Model class,
# for being able to run inference through the sagemaker API.
base_model_predictor = model.deploy(
    initial_instance_count=1,
    instance_type=inference_instance_type,
    predictor_cls=Predictor,
    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!

Följande kodavsnitt ger dig en glimt av hur semantisk segmentering ser ut. Den förutsagda masken för varje pixel visualiseras. För att få slutsatser från en distribuerad modell måste en indatabild tillhandahållas i binärt format. Slutpunktens svar är en förutspådd etikett för varje pixel i bilden. Vi använder query_endpoint och parse_response hjälpfunktioner, som definieras i medföljande anteckningsbok:

query_response = query(base_model_predictor, pedestrian_img)
predictions, labels, image_labels = parse_response(query_response)
print("Objects present in the picture:", image_labels)

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 vilken 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 = "mxnet-semseg-fcn-resnet50-ade", "*"
training_instance_type = "ml.p3.2xlarge"
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. Du kan nu finjustera denna JumpStart-modell på din egen anpassade datauppsättning med SageMaker SDK. Vi använder en datauppsättning som är offentligt värd på Amazon S3, bekvämt fokuserad på semantisk segmentering. Datauppsättningen bör vara strukturerad för finjustering enligt beskrivningen i föregående avsnitt. Se följande exempelkod:

# URI of your training dataset
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/PennFudanPed_SemSeg/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"
training_job_name = name_from_base(f"jumpstart-example-{model_id}-transfer-learning")# Create SageMaker Estimator instance
semseg_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
semseg_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 metod för att börja finjustera vår modell och skicka den till Amazon S3 URI för våra träningsdata. De 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.

Medan algoritmen tränar kan du övervaka dess framsteg antingen i SageMaker-anteckningsboken där du kör själva koden, eller på amazoncloudwatch. När utbildningen är klar laddas de finjusterade modellartefakterna upp till Amazon S3-utgångsplatsen som anges i träningskonfigurationen. Du kan nu distribuera modellen på samma sätt som den förtränade modellen.

Avancerade funktioner

Förutom att finjustera och distribuera förtränade modeller, erbjuder JumpStart många avancerade funktioner.

Den första är automatisk modellinställning. Detta gör att du automatiskt kan ställa in dina ML-modeller för att hitta hyperparametervärdena med högsta noggrannhet inom det intervall som tillhandahålls genom SageMaker API.

Det andra är stegvis utbildning. Detta gör att du kan 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.

Slutsats

I det här inlägget visade vi hur man finjusterar och distribuerar en förtränad semantisk segmenteringsmodell, och hur man anpassar den till exempel segmentering med JumpStart. Du kan åstadkomma detta utan att behöva skriva kod. Prova lösningen på egen hand och skicka oss dina kommentarer.

För att lära dig mer om JumpStart och hur du kan använda förtränade modeller med öppen källkod för en mängd andra ML-uppgifter, kolla in följande AWS re:Invent 2020-video.

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 på EMNLP-, ICLR-, COLT-, FOCS- och SODA-konferenser.

Santosh Kulkarni är en Enterprise Solutions Architect på Amazon Web Services som arbetar med sportkunder i Australien. Han brinner för att bygga storskaliga distribuerade applikationer för att lösa affärsproblem med sin kunskap inom AI/ML, big data och mjukvaruutveckling.

Leonardo Bachega är senior vetenskapsman och chef i Amazon SageMaker JumpStart-teamet. Han brinner för att bygga AI-tjänster för datorseende.