Kjør bildesegmentering med Amazon SageMaker JumpStart

I desember 2020, AWS annonsert 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). 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.

Dette innlegget er det tredje i en serie om bruk av JumpStart for spesifikke ML-oppgaver. I første innlegg, viste vi hvordan du kan kjøre brukstilfeller for bildeklassifisering på JumpStart. I andre innlegg, viste vi hvordan du kan kjøre brukstilfeller for tekstklassifisering på JumpStart. I dette innlegget gir vi en trinnvis gjennomgang av hvordan du finjusterer og distribuerer en bildesegmenteringsmodell, ved å bruke opplærte modeller fra MXNet. Vi utforsker to måter å oppnå det samme resultatet på: via JumpStarts grafiske grensesnitt på Amazon SageMaker Studio, og programmatisk gjennom JumpStart APIer.

Hvis du vil hoppe rett inn i JumpStart API-koden vi forklarer i dette innlegget, kan du referere til følgende eksempel på Jupyter-notatbøker:

JumpStart oversikt

JumpStart hjelper deg med å komme i gang med ML-modeller for en rekke oppgaver uten å skrive en eneste linje med kode. 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.
• 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 domene 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, for eksempel 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.
• Se eksempler på bærbare datamaskiner 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 for 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.

Semantisk segmentering

Semantisk segmentering avgrenser hver klasse av objekter som vises i et inngangsbilde. Den merker (klassifiserer) hver piksel i inndatabildet med en klasseetikett fra et forhåndsdefinert sett med klasser. Flere objekter av samme klasse er tilordnet til samme maske.

Modellen som er tilgjengelig for finjustering bygger et "full convolutional network" (FCN) "hode" på toppen av basisnettverket. Finjusteringstrinnet finjusterer FCNHead mens parametrene for resten av modellen er frosset, og returnerer den finjusterte modellen. Målet er å minimere per-piksel softmax kryssentropitap for å trene FCN. Modellen som returneres ved finjustering kan distribueres videre for slutninger.

Inndatakatalogen skal se ut som følgende kode hvis treningsdataene inneholder to bilder. Navnene på .png-filene kan være hva som helst.

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

Maskefilene skal ha klasseetikettinformasjon for hver piksel.

Instanssegmentering

Forekomstsegmentering oppdager og avgrenser hvert enkelt objekt av interesse som vises i et bilde. Den merker hver piksel med en forekomstetikett. Mens semantisk segmentering tildeler den samme taggen til piksler av flere objekter av samme klasse, merker forekomstsegmentering ytterligere piksler som tilsvarer hver forekomst av et objekt på bildet med en separat kode.

Foreløpig tilbyr JumpStart modeller som kun er inferens, for eksempel segmentering og støtter ikke finjustering.

Følgende bilder illustrerer forskjellen mellom slutningen i semantisk segmentering og instanssegmentering. Originalbildet har to personer i bildet. Semantisk segmentering behandler flere personer i bildet som én enhet: Person. Forekomstsegmentering identifiserer imidlertid individuelle personer innenfor Person kategori.

Løsningsoversikt

Følgende seksjoner gir en trinn-for-trinn-demo for å utføre semantisk segmentering med JumpStart, både via Studio UI og via JumpStart APIer.

Vi går gjennom følgende trinn:

1. Få tilgang til JumpStart gjennom Studio UI:
   1. Kjør slutning på den forhåndstrente modellen.
   2. Finjuster den ferdigtrente modellen.
2. Bruk JumpStart programmatisk med SageMaker Python SDK:
   1. Kjør slutning på den forhåndstrente modellen.
   2. Finjuster den ferdigtrente modellen.

Vi diskuterer også flere avanserte funksjoner i JumpStart.

Få tilgang til JumpStart gjennom Studio UI

I denne delen viser vi hvordan du trener og distribuerer JumpStart-modeller gjennom Studio UI.

Kjør slutning på den forhåndstrente modellen

Følgende video viser deg hvordan du finner en forhåndstrent semantisk segmenteringsmodell på JumpStart og distribuerer den. Modellsiden inneholder verdifull informasjon om modellen, hvordan du bruker den, forventet dataformat og noen finjusteringsdetaljer. Du kan distribuere hvilken som helst av de forhåndstrente modellene som er tilgjengelige i JumpStart. For slutninger velger vi forekomsttypen ml.g4dn.xlarge. Det gir 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.

Etter noen minutter er endepunktet ditt operativt og klart til å svare på slutningsforespørsler.

På samme måte kan du distribuere en forhåndsopplært forekomstsegmenteringsmodell ved å følge de samme trinnene i den foregående videoen mens du søker etter for eksempel segmentering i stedet for semantisk segmentering i JumpStart-søkefeltet.

Finjuster den ferdigtrente modellen

Følgende video viser hvordan du finner og finjusterer en semantisk segmenteringsmodell i JumpStart. I videoen finjusterer vi modellen ved hjelp av PennFudanPed datasett, gitt som standard i JumpStart, som du kan laste ned under Apache 2.0-lisens.

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 som vår SageMaker-treningsinstans.

Du kan overvåke treningsjobben din som kjører direkte på Studio-konsollen, og blir varslet når den er fullført. Etter at opplæringen er fullført, kan du distribuere den finjusterte modellen fra samme side som inneholder treningsjobbdetaljene. Arbeidsflyten for distribusjon er den samme som å distribuere en forhåndsopplært modell.

Bruk JumpStart programmatisk med SageMaker SDK

I de foregående delene viste vi hvordan du kan bruke JumpStart-grensesnittet til å distribuere en forhåndsopplært modell og finjustere den interaktivt, i løpet av noen få klikk. Du kan imidlertid 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 – Forekomstsegmentering og Introduksjon til JumpStart – Semantisk segmentering.

Kjør slutning på den forhåndstrente modellen

I denne delen velger vi en passende forhåndsopplært modell i JumpStart, distribuerer denne modellen til et SageMaker-endepunkt og kjører slutning om det utplasserte endepunktet.

SageMaker er en plattform basert på Docker-containere. JumpStart bruker den tilgjengelige rammespesifikke SageMaker Deep Learning-beholdere (DLC-er). Vi henter eventuelle tilleggspakker, samt skript for å håndtere opplæring og slutninger for den valgte oppgaven. Til slutt hentes de forhåndstrente modellartefaktene separat med model_uris, som gir fleksibilitet til plattformen. Du kan bruke et hvilket som helst antall modeller som er forhåndsopplært for samme oppgave med ett enkelt trenings- eller slutningsskript. 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 angi model_id til mxnet-semseg-fcn-resnet50-ade. er i identifikatoren tilsvarer forekomstsegmentering.

Deretter mater vi ressursene inn i en SageMaker modell forekomst og distribuer et endepunkt:

# 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,
)

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

Følgende kodebit gir deg et glimt av hvordan semantisk segmentering ser ut. Den forutsagte masken for hver piksel visualiseres. For å få slutninger fra en distribuert modell, må et inngangsbilde leveres i binært format. Responsen til endepunktet er en forutsagt etikett for hver piksel i bildet. Vi bruker query_endpoint og parse_response hjelpefunksjoner, som er definert i medfølgende notatbok:

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 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 typen 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 = "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 tilsvarende den samme modellen vi brukte tidligere. Du kan nå finjustere denne JumpStart-modellen på ditt eget tilpassede datasett ved å bruke SageMaker SDK. Vi bruker et datasett som er offentlig hostet på Amazon S3, praktisk fokusert på semantisk segmentering. Datasettet bør være strukturert for finjustering som forklart i forrige avsnitt. 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 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 metode for å begynne å finjustere modellen vår ved å gi den Amazon S3 URI for treningsdataene våre. De entry_point skriptet som er oppgitt heter transfer_learning.py (det samme for andre oppgaver og modeller), og inngangsdatakanalen sendes til .fit må navngis training.

Mens algoritmen trener, kan du overvåke fremdriften enten i SageMaker-notisboken der du kjører selve koden, eller på Amazon CloudWatch. Når treningen er fullført, lastes de finjusterte modellartefaktene opp til Amazon S3-utgangsstedet spesifisert i treningskonfigurasjonen. Du kan nå distribuere modellen på samme måte som den forhåndstrente modellen.

Avanserte funksjoner

I tillegg til å finjustere og distribuere ferdigtrente modeller, tilbyr JumpStart mange avanserte funksjoner.

Den første er automatisk modellinnstilling. Dette lar deg justere ML-modellene dine automatisk for å finne hyperparameterverdiene med høyeste nøyaktighet innenfor området gitt gjennom SageMaker API.

Den andre er trinnvis opplæring. Dette 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.

konklusjonen

I dette innlegget viste vi hvordan du finjusterer og distribuerer en forhåndsopplært semantisk segmenteringsmodell, og hvordan du tilpasser den for eksempel segmentering ved hjelp av JumpStart. Du kan oppnå dette uten å måtte skrive kode. Prøv løsningen på egen hånd og send oss ​​dine kommentarer.

For å lære mer om JumpStart og hvordan du kan bruke åpen kildekode ferdigtrente modeller for en rekke andre ML-oppgaver, sjekk ut følgende AWS re:Invent 2020-video.

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.

Santosh Kulkarni er en Enterprise Solutions Architect hos Amazon Web Services som jobber med sportskunder i Australia. Han brenner for å bygge distribuerte applikasjoner i stor skala for å løse forretningsproblemer ved å bruke sin kunnskap innen AI/ML, big data og programvareutvikling.

Leonardo Bachega er seniorforsker og leder i Amazon SageMaker JumpStart-teamet. Han brenner for å bygge AI-tjenester for datasyn.