Kør billedsegmentering med Amazon SageMaker JumpStart

I december 2020, AWS annonceret 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). JumpStart giver et-klik finjustering og implementering 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.

Dette indlæg er det tredje i en serie om brug af JumpStart til specifikke ML-opgaver. I den første indlæg, viste vi, hvordan du kan køre billedklassificeringsbrug på JumpStart. I den andet indlæg, viste vi, hvordan du kan køre tekstklassificering use cases på JumpStart. I dette indlæg giver vi en trin-for-trin gennemgang af, hvordan man finjusterer og implementerer en billedsegmenteringsmodel ved hjælp af trænede modeller fra MXNet. Vi udforsker to måder at opnå det samme resultat på: via JumpStarts grafiske interface på Amazon SageMaker Studio, og programmæssigt igennem JumpStart API'er.

Hvis du vil springe direkte ind i JumpStart API-koden, vi forklarer i dette indlæg, kan du henvise til følgende eksempler på Jupyter-notebooks:

JumpStart oversigt

JumpStart hjælper dig med at komme i gang med ML-modeller til en række forskellige opgaver uden at skrive en enkelt linje kode. 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 som TensorFlow, PyTorch, Hugging Face og MXNet.
• 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 domæne 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.
• Se notebook-eksempler for 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 bruge 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.

Semantisk segmentering

Semantisk segmentering afgrænser hver klasse af objekter, der vises i et inputbillede. Den mærker (klassificerer) hver pixel i inputbilledet med en klasseetiket fra et foruddefineret sæt klasser. Flere objekter af samme klasse er knyttet til den samme maske.

Den model, der er tilgængelig til finjustering, bygger et "fuldt konvolutionelt netværk" (FCN) "hoved" oven på basisnetværket. Finjusteringstrinnet finjusterer FCNHead, mens parametrene for resten af ​​modellen fastfryses, og returnerer den finjusterede model. Målet er at minimere per-pixel softmax krydsentropitab for at træne FCN. Den model, der returneres ved finjustering, kan videreudvikles til slutninger.

Indtastningsbiblioteket skal se ud som følgende kode, hvis træningsdataene indeholder to billeder. Navnene på .png-filerne kan være hvad som helst.

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

Maskefilerne skal have klasselabeloplysninger for hver pixel.

Forekomstsegmentering

Forekomstsegmentering registrerer og afgrænser hvert enkelt objekt af interesse, der vises i et billede. Den mærker hver pixel med en instansetiket. Mens semantisk segmentering tildeler det samme tag til pixels af flere objekter af samme klasse, mærker instanssegmentering yderligere pixels svarende til hver forekomst af et objekt på billedet med et separat tag.

I øjeblikket tilbyder JumpStart modeller, der kun er inferens, for eksempel segmentering og understøtter ikke finjustering.

Følgende billeder illustrerer forskellen mellem inferensen i semantisk segmentering og instanssegmentering. Det originale billede har to personer på billedet. Semantisk segmentering behandler flere personer på billedet som én enhed: Person. Imidlertid identificerer instanssegmentering individuelle personer inden for Person kategori.

Løsningsoversigt

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

Vi gennemgår følgende trin:

1. Få adgang til JumpStart gennem Studio UI:
   1. Kør inferens på den fortrænede model.
   2. Finjuster den fortrænede model.
2. Brug JumpStart programmatisk med SageMaker Python SDK:
   1. Kør inferens på den fortrænede model.
   2. Finjuster den fortrænede model.

Vi diskuterer også yderligere avancerede funktioner i JumpStart.

Få adgang til JumpStart gennem Studio UI

I dette afsnit demonstrerer vi, hvordan man træner og implementerer JumpStart-modeller gennem Studio UI.

Kør inferens på den fortrænede model

Den følgende video viser dig, hvordan du finder en forudtrænet semantisk segmenteringsmodel på JumpStart og implementerer den. Modelsiden indeholder værdifuld information om modellen, hvordan den bruges, forventet dataformat og nogle finjusteringsdetaljer. Du kan implementere enhver af de fortrænede modeller, der er tilgængelige i JumpStart. Som slutning vælger vi instanstypen ml.g4dn.xlarge. Det giver 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.

Efter et par minutter er dit slutpunkt operationelt og klar til at svare på anmodninger om slutninger.

På samme måde kan du implementere en forudtrænet instanssegmenteringsmodel ved at følge de samme trin i den foregående video, mens du søger efter f.eks. segmentering i stedet for semantisk segmentering i JumpStart-søgelinjen.

Finjuster den fortrænede model

Den følgende video viser, hvordan man finder og finjusterer en semantisk segmenteringsmodel i JumpStart. I videoen finjusterer vi modellen ved hjælp af PennFudanPed datasæt, leveret som standard i JumpStart, som du kan downloade under Apache 2.0-licens.

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 som vores SageMaker-træningsinstans.

Du kan overvåge dit træningsjob, der kører direkte på Studio-konsollen og får besked, når det er afsluttet. Når træningen er fuldført, kan du implementere den finjusterede model fra den samme side, som indeholder oplysningerne om træningsjob. Implementeringsworkflowet er det samme som at implementere en præ-trænet model.

Brug JumpStart programmatisk med SageMaker SDK

I de foregående afsnit viste vi, hvordan du kan bruge JumpStart-brugergrænsefladen til at implementere en forudtrænet model og finjustere den interaktivt med få klik. Du kan dog også bruge JumpStarts modeller og nem at finjustere 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 – Instance Segmentation , Introduktion til JumpStart – Semantisk segmentering.

Kør inferens på den fortrænede model

I dette afsnit vælger vi en passende præ-trænet model i JumpStart, implementerer denne model til et SageMaker-slutpunkt og kører konklusioner om det implementerede slutpunkt.

SageMaker er en platform baseret på Docker-containere. JumpStart bruger den tilgængelige rammespecifikke SageMaker Deep Learning Containere (DLC'er). Vi henter eventuelle yderligere pakker, samt scripts til at håndtere træning og slutninger til den valgte opgave. Til sidst hentes de fortrænede modelartefakter separat med model_uris, hvilket giver fleksibilitet til platformen. Du kan bruge et hvilket som helst antal modeller, der er foruddannet til den samme opgave med et enkelt trænings- eller inferensscript. Se følgende kode:

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

For eksempel segmentering kan vi indstille model_id til mxnet-semseg-fcn-resnet50-ade. Det er i identifikatoren svarer til instanssegmentering.

Dernæst tilfører vi ressourcerne til en SageMaker model instans og implementer et 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 et par minutter er vores model implementeret, og vi kan få forudsigelser fra den i realtid!

Følgende kodestykke giver dig et glimt af, hvordan semantisk segmentering ser ud. Den forudsagte maske for hver pixel visualiseres. For at få slutninger fra en implementeret model skal et inputbillede leveres i binært format. Slutpunktets respons er en forudsagt etiket for hver pixel i billedet. Vi bruger query_endpoint , parse_response hjælpefunktioner, som er defineret i medfølgende notesbog:

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

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 de tilgængelige modeller, se JumpStart tilgængelig model tabel), og hvilken 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 = "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 henter model_id svarende til den samme model, som vi brugte tidligere. Du kan nu finjustere denne JumpStart-model på dit eget brugerdefinerede datasæt ved hjælp af SageMaker SDK. Vi bruger et datasæt, der er offentligt hostet på Amazon S3, bekvemt fokuseret på semantisk segmentering. Datasættet skal være struktureret til finjustering som forklaret i det foregående afsnit. Se følgende eksempelkode:

# 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 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 metode til at begynde at finjustere vores model ved at give den Amazon S3 URI til vores træningsdata. Det entry_point det angivne script hedder transfer_learning.py (det samme for andre opgaver og modeller), og inputdatakanalen videregives til .fit skal navngives training.

Mens algoritmen træner, kan du overvåge dens fremskridt enten i SageMaker notesbogen, hvor du kører selve koden, eller på amazoncloudwatch. Når træningen er færdig, uploades de finjusterede modelartefakter til Amazon S3-outputstedet, der er angivet i træningskonfigurationen. Du kan nu implementere modellen på samme måde som den fortrænede model.

Avancerede funktioner

Ud over at finjustere og implementere fortrænede modeller tilbyder JumpStart mange avancerede funktioner.

Den første er automatisk model tuning. Dette giver dig mulighed for automatisk at tune dine ML-modeller for at finde hyperparameterværdierne med den højeste nøjagtighed inden for det område, der leveres gennem SageMaker API.

Den anden er trinvis træning. Dette 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.

Konklusion

I dette indlæg viste vi, hvordan man finjusterer og implementerer en forudtrænet semantisk segmenteringsmodel, og hvordan man tilpasser den for eksempel segmentering ved hjælp af JumpStart. Du kan opnå dette uden at skulle skrive kode. Prøv løsningen på egen hånd og send os dine kommentarer.

For at lære mere om JumpStart og hvordan du kan bruge open source-foruddannede modeller til en række andre ML-opgaver, tjek følgende AWS re: Invent 2020-video.

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 postdoktor 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.

Santosh Kulkarni er en Enterprise Solutions Architect hos Amazon Web Services, der arbejder med sportskunder i Australien. Han brænder for at bygge store distribuerede applikationer til at løse forretningsproblemer ved at bruge sin viden inden for AI/ML, big data og softwareudvikling.

Leonardo Bachega er seniorforsker og leder i Amazon SageMaker JumpStart-teamet. Han brænder for at bygge AI-tjenester til computersyn.