Voer beeldsegmentatie uit met Amazon SageMaker JumpStart

In december 2020, AWS aangekondigd de algemene beschikbaarheid van Amazon SageMaker JumpStart, een vermogen van Amazon Sage Maker waarmee je snel en eenvoudig aan de slag gaat met machine learning (ML). JumpStart biedt fijnafstemming en implementatie met één klik van een breed scala aan vooraf getrainde modellen voor populaire ML-taken, evenals een selectie van end-to-end-oplossingen die veelvoorkomende zakelijke problemen oplossen. Deze functies verwijderen het zware werk van elke stap van het ML-proces, waardoor het gemakkelijker wordt om hoogwaardige modellen te ontwikkelen en de implementatietijd te verkorten.

Dit bericht is het derde in een serie over het gebruik van JumpStart voor specifieke ML-taken. In de eerste bericht, hebben we laten zien hoe u gebruiksscenario's voor beeldclassificatie kunt uitvoeren op JumpStart. In de tweede bericht, hebben we laten zien hoe u use-cases voor tekstclassificatie kunt uitvoeren op JumpStart. In dit bericht bieden we een stapsgewijze uitleg over het verfijnen en implementeren van een beeldsegmentatiemodel met behulp van getrainde modellen van MXNet. We onderzoeken twee manieren om hetzelfde resultaat te verkrijgen: via de grafische interface van JumpStart op Amazon SageMaker Studio, en programmatisch door JumpStart-API's.

Als je direct in de JumpStart API-code wilt springen die we in dit bericht uitleggen, kun je de volgende voorbeelden van Jupyter-notebooks raadplegen:

JumpStart-overzicht

JumpStart helpt u aan de slag te gaan met ML-modellen voor verschillende taken zonder ook maar één regel code te hoeven schrijven. Op het moment van schrijven kunt u met JumpStart het volgende doen:

• Vooraf getrainde modellen implementeren voor veelvoorkomende ML-taken – JumpStart stelt u in staat om veelvoorkomende ML-taken aan te pakken zonder ontwikkelingsinspanningen door eenvoudige implementatie te bieden van modellen die vooraf zijn getraind op grote, openbaar beschikbare datasets. De ML-onderzoeksgemeenschap heeft veel moeite gedaan om de meeste recent ontwikkelde modellen openbaar beschikbaar te maken voor gebruik. JumpStart host een verzameling van meer dan 300 modellen, verspreid over de 15 meest populaire ML-taken, zoals objectdetectie, tekstclassificatie en tekstgeneratie, waardoor het voor beginners gemakkelijk is om ze te gebruiken. Deze modellen zijn afkomstig van populaire modelhubs zoals TensorFlow, PyTorch, Hugging Face en MXNet.
• Vooraf getrainde modellen afstemmen - Met JumpStart kunt u vooraf getrainde modellen verfijnen zonder dat u uw eigen trainingsalgoritme hoeft te schrijven. In ML wordt het vermogen om de kennis die in het ene domein is geleerd over te dragen naar een ander domein genoemd overdracht leren. U kunt transfer learning gebruiken om nauwkeurige modellen te produceren op uw kleinere datasets, met veel lagere trainingskosten dan de kosten voor het trainen van het originele model. JumpStart bevat ook populaire trainingsalgoritmen op basis van LightGBM, CatBoost, XGBoost en Scikit-learn, die u helemaal opnieuw kunt trainen voor tabelregressie en classificatie.
• Gebruik kant-en-klare oplossingen – JumpStart biedt een set van 17 oplossingen voor veelvoorkomende ML-gebruiksscenario's, zoals vraagvoorspelling en industriële en financiële toepassingen, die u met slechts een paar klikken kunt implementeren. Oplossingen zijn end-to-end ML-applicaties die verschillende AWS-services aaneenrijgen om een ​​bepaalde zakelijke use-case op te lossen. Ze gebruiken AWS CloudFormatie sjablonen en referentiearchitecturen voor snelle implementatie, wat betekent dat ze volledig aanpasbaar zijn.
• Raadpleeg notebookvoorbeelden voor SageMaker-algoritmen – SageMaker biedt een reeks ingebouwde algoritmen om datawetenschappers en ML-beoefenaars te helpen snel aan de slag te gaan met het trainen en implementeren van ML-modellen. JumpStart biedt voorbeeldnotitieblokken die u kunt gebruiken om deze algoritmen snel te gebruiken.
• Bekijk trainingsvideo's en blogs – JumpStart biedt ook tal van blogberichten en video's die u leren hoe u verschillende functionaliteiten binnen SageMaker kunt gebruiken.

JumpStart accepteert aangepaste VPC-instellingen en AWS Sleutelbeheerservice (AWS KMS) encryptiesleutels, zodat u de beschikbare modellen en oplossingen veilig kunt gebruiken binnen uw bedrijfsomgeving. U kunt uw beveiligingsinstellingen doorgeven aan JumpStart in Studio of via de SageMaker Python SDK.

Semantische segmentatie

Semantische segmentatie schetst elke klasse van objecten die in een invoerbeeld verschijnen. Het tagt (classificeert) elke pixel van de invoerafbeelding met een klasselabel uit een vooraf gedefinieerde reeks klassen. Meerdere objecten van dezelfde klasse worden toegewezen aan hetzelfde masker.

Het model dat beschikbaar is voor fijnafstemming bouwt een volledig convolutionele netwerk (FCN) "kop" bovenop het basisnetwerk. De fijnafstellingsstap verfijnt de FCNHead terwijl de parameters van de rest van het model bevroren blijven, en geeft het verfijnde model terug. Het doel is om per pixel softmax cross-entropieverlies te minimaliseren om de FCN te trainen. Het model dat door fine-tuning wordt geretourneerd, kan verder worden ingezet voor gevolgtrekking.

De invoermap moet eruitzien als de volgende code als de trainingsgegevens twee afbeeldingen bevatten. De namen van de .png-bestanden kunnen van alles zijn.

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

De maskerbestanden moeten klasselabelinformatie voor elke pixel hebben.

Instantiesegmentatie

Met instantiesegmentatie wordt elk afzonderlijk object van belang dat in een afbeelding wordt weergegeven, gedetecteerd en afgebakend. Het tagt elke pixel met een instantielabel. Terwijl semantische segmentatie dezelfde tag toewijst aan pixels van meerdere objecten van dezelfde klasse, labelt instantiesegmentatie verder pixels die overeenkomen met elk voorkomen van een object op de afbeelding met een aparte tag.

Op dit moment biedt JumpStart alleen inferentiemodellen voor bijvoorbeeld segmentatie en ondersteunt het geen fijnafstemming.

De volgende afbeeldingen illustreren het verschil tussen de gevolgtrekking in semantische segmentatie en instantiesegmentatie. De originele afbeelding heeft twee mensen in de afbeelding. Semantische segmentatie behandelt meerdere mensen in de afbeelding als één entiteit: Person. Echter, instantiesegmentatie identificeert individuele mensen binnen de Person categorie.

Overzicht oplossingen

De volgende secties bieden een stapsgewijze demo voor het uitvoeren van semantische segmentatie met JumpStart, zowel via de Studio UI als via JumpStart API's.

We doorlopen de volgende stappen:

1. Toegang tot JumpStart via de Studio UI:
   1. Voer gevolgtrekkingen uit op het vooraf getrainde model.
   2. Verfijn het voorgetrainde model.
2. Gebruik JumpStart programmatisch met de SageMaker Python SDK:
   1. Voer gevolgtrekkingen uit op het vooraf getrainde model.
   2. Verfijn het voorgetrainde model.

We bespreken ook aanvullende geavanceerde functies van JumpStart.

Toegang tot JumpStart via de Studio UI

In deze sectie laten we zien hoe u JumpStart-modellen kunt trainen en implementeren via de Studio UI.

Voer gevolgtrekkingen uit op het vooraf getrainde model

In de volgende video ziet u hoe u een vooraf getraind semantisch segmentatiemodel op JumpStart kunt vinden en kunt implementeren. De modelpagina bevat waardevolle informatie over het model, hoe het te gebruiken, het verwachte gegevensformaat en enkele details voor fijnafstelling. U kunt elk van de vooraf getrainde modellen implementeren die beschikbaar zijn in JumpStart. Voor gevolgtrekking kiezen we het instantietype ml.g4dn.xlarge. Het biedt de GPU-versnelling die nodig is voor lage inferentielatentie, maar tegen een lagere prijs. Nadat u de SageMaker-hostinginstantie hebt geconfigureerd, kiest u: Implementeren. Het kan 5-10 minuten duren voordat uw permanente eindpunt actief is.

Na een paar minuten is uw eindpunt operationeel en klaar om te reageren op inferentieverzoeken.

Op dezelfde manier kunt u een vooraf getraind exemplaarsegmentatiemodel implementeren door dezelfde stappen in de voorgaande video te volgen terwijl u zoekt naar exemplaarsegmentatie in plaats van semantische segmentatie in de JumpStart-zoekbalk.

Verfijn het voorgetrainde model

De volgende video laat zien hoe u een semantisch segmentatiemodel in JumpStart kunt vinden en verfijnen. In de video verfijnen we het model met behulp van de PennFudanPed-gegevensset, standaard geleverd in JumpStart, die u kunt downloaden onder de Apache 2.0-licentie.

Het finetunen van uw eigen dataset omvat het nemen van de juiste opmaak van data (zoals uitgelegd op de modelpagina), het uploaden naar Amazon eenvoudige opslagservice (Amazon S3), en met vermelding van de locatie in de gegevensbronconfiguratie. We gebruiken dezelfde hyperparameterwaarden die standaard zijn ingesteld (aantal tijdperken, leersnelheid en batchgrootte). We gebruiken ook een door GPU ondersteunde ml.p3.2xlarge als onze SageMaker-trainingsinstantie.

U kunt uw trainingstaak rechtstreeks op de Studio-console volgen en u ontvangt een melding wanneer deze is voltooid. Nadat de training is voltooid, kunt u het verfijnde model implementeren vanaf dezelfde pagina met de details van de trainingstaak. De implementatieworkflow is hetzelfde als het implementeren van een vooraf getraind model.

Gebruik JumpStart programmatisch met de SageMaker SDK

In de voorgaande paragrafen hebben we laten zien hoe u de JumpStart UI kunt gebruiken om een ​​vooraf getraind model te implementeren en interactief te verfijnen, in een kwestie van een paar klikken. U kunt echter ook de modellen van JumpStart gebruiken en eenvoudig programmatisch afstemmen met behulp van API's die zijn geïntegreerd in de SageMaker SDK. We bespreken nu een snel voorbeeld van hoe u het voorgaande proces kunt repliceren. Alle stappen in deze demo zijn beschikbaar in de bijbehorende notitieboekjes Inleiding tot JumpStart – instantiesegmentatie en Inleiding tot JumpStart – Semantische segmentatie.

Voer gevolgtrekkingen uit op het vooraf getrainde model

In deze sectie kiezen we een geschikt, vooraf getraind model in JumpStart, implementeren dit model op een SageMaker-eindpunt en voeren inferentie uit op het geïmplementeerde eindpunt.

SageMaker is een platform gebaseerd op Docker-containers. JumpStart gebruikt de beschikbare framework-specifieke SageMaker Deep Learning-containers (DLC's). We halen eventuele aanvullende pakketten op, evenals scripts om training en gevolgtrekking voor de geselecteerde taak af te handelen. Ten slotte worden de vooraf getrainde modelartefacten afzonderlijk opgehaald met model_uris, wat het platform flexibiliteit biedt. U kunt een willekeurig aantal modellen gebruiken die vooraf zijn getraind voor dezelfde taak met een enkel trainings- of inferentiescript. Zie de volgende code:

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

Segmentatie kunnen we bijvoorbeeld instellen model_id naar mxnet-semseg-fcn-resnet50-ade. De is in de identifier komt overeen met instantiesegmentatie.

Vervolgens voeren we de middelen in a SageMaker-model instantie en implementeer een eindpunt:

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

Na een paar minuten is ons model geïmplementeerd en kunnen we er in realtime voorspellingen van krijgen!

Het volgende codefragment geeft u een idee van hoe semantische segmentatie eruitziet. Het voorspelde masker voor elke pixel wordt gevisualiseerd. Om gevolgtrekkingen van een geïmplementeerd model te krijgen, moet een invoerafbeelding in binair formaat worden aangeleverd. De respons van het eindpunt is een voorspeld label voor elke pixel in de afbeelding. Wij gebruiken de query_endpoint en parse_response helperfuncties, die zijn gedefinieerd in de bijbehorende notebook:

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

Verfijn het voorgetrainde model

Om een ​​geselecteerd model te verfijnen, hebben we de URI van dat model nodig, evenals die van het trainingsscript en de containerafbeelding die voor de training wordt gebruikt. Gelukkig zijn deze drie ingangen uitsluitend afhankelijk van de modelnaam, versie (voor een lijst van de beschikbare modellen, zie JumpStart Beschikbare Model Tabel), en het type instantie waarop u wilt trainen. Dit wordt gedemonstreerd in het volgende codefragment:

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

We halen de model_id overeenkomend met hetzelfde model dat we eerder gebruikten. U kunt dit JumpStart-model nu verfijnen op uw eigen aangepaste dataset met behulp van de SageMaker SDK. We gebruiken een dataset die openbaar wordt gehost op Amazon S3, handig gericht op semantische segmentatie. De dataset moet worden gestructureerd voor fine-tuning, zoals uitgelegd in de vorige sectie. Zie de volgende voorbeeldcode:

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

We verkrijgen dezelfde standaard hyperparameters voor ons geselecteerde model als degene die we in de vorige sectie zagen, met behulp van sagemaker.hyperparameters.retrieve_default(). We instantiëren dan een SageMaker-schatter en noemen de .fit methode om ons model te verfijnen en het de Amazon S3 URI door te geven voor onze trainingsgegevens. De entry_point het geleverde script heet transfer_learning.py (hetzelfde voor andere taken en modellen), en het invoergegevenskanaal wordt doorgegeven aan .fit moet worden genoemd training.

Terwijl het algoritme traint, kunt u de voortgang ervan volgen in de SageMaker-notebook waar u de code zelf uitvoert, of op Amazon Cloud Watch. Wanneer de training is voltooid, worden de nauwkeurig afgestemde modelartefacten geüpload naar de Amazon S3-uitvoerlocatie die is opgegeven in de trainingsconfiguratie. U kunt het model nu op dezelfde manier implementeren als het vooraf getrainde model.

Geavanceerde functies

Naast het verfijnen en inzetten van vooraf getrainde modellen, biedt JumpStart veel geavanceerde functies.

De eerste is automatische modelafstemming. Hierdoor kunt u uw ML-modellen automatisch afstemmen om de hyperparameterwaarden te vinden met de hoogste nauwkeurigheid binnen het bereik dat wordt geboden door de SageMaker API.

De tweede is incrementele training. Hierdoor kunt u een model trainen dat u al hebt verfijnd met behulp van een uitgebreide dataset die een onderliggend patroon bevat dat niet is meegenomen in eerdere fine-tuning-runs, wat resulteerde in slechte modelprestaties. Incrementele training bespaart zowel tijd als middelen omdat u het model niet helemaal opnieuw hoeft te trainen.

Conclusie

In dit bericht hebben we laten zien hoe je een vooraf getraind semantisch segmentatiemodel kunt verfijnen en implementeren, en hoe je het kunt aanpassen voor bijvoorbeeld segmentatie met behulp van JumpStart. U kunt dit bereiken zonder dat u code hoeft te schrijven. Probeer de oplossing zelf uit en stuur ons uw opmerkingen.

Bekijk het volgende voor meer informatie over JumpStart en hoe u voorgetrainde open-sourcemodellen kunt gebruiken voor tal van andere ML-taken AWS re:Invent 2020-video.

Over de auteurs

Dr Vivek Madan is een Applied Scientist bij het Amazon SageMaker JumpStart-team. Hij promoveerde aan de Universiteit van Illinois in Urbana-Champaign en was een postdoctoraal onderzoeker bij Georgia Tech. Hij is een actief onderzoeker op het gebied van machine learning en algoritmeontwerp en heeft artikelen gepubliceerd op EMNLP-, ICLR-, COLT-, FOCS- en SODA-conferenties.

Santosh Kulkarni is een Enterprise Solutions Architect bij Amazon Web Services die werkt met sportklanten in Australië. Hij is gepassioneerd door het bouwen van grootschalige gedistribueerde applicaties om zakelijke problemen op te lossen met behulp van zijn kennis van AI/ML, big data en softwareontwikkeling.

Leonardo Bachega is senior wetenschapper en manager in het Amazon SageMaker JumpStart-team. Hij is gepassioneerd door het bouwen van AI-services voor computervisie.