Dit is een gastblogpost die is geschreven in samenwerking met Ben Veasey, Jeremy Anderson, Jordan Knight en June Li van Travellers.

Satelliet- en luchtbeelden geven inzicht in een breed scala aan problemen, waaronder precisielandbouw, verzekeringsrisicobeoordeling, stedelijke ontwikkeling en rampenbestrijding. Het trainen van machine learning (ML)-modellen om deze gegevens te interpreteren, wordt echter belemmerd door kostbare en tijdrovende menselijke annotatie-inspanningen. Een manier om deze uitdaging te overwinnen is door zelfstandig leren (SSL). Door te trainen op grote hoeveelheden niet-gelabelde beeldgegevens, leren modellen met zelfbeheer beeldrepresentaties die kunnen worden overgedragen naar stroomafwaartse taken, zoals beeldclassificatie of segmentatie. Deze benadering produceert beeldrepresentaties die goed generaliseren naar ongeziene gegevens en vermindert de hoeveelheid gelabelde gegevens die nodig zijn om performante downstream-modellen te bouwen.

In dit bericht laten we zien hoe u zelfbegeleide vision-transformatoren kunt trainen op overheadbeelden met behulp van Amazon Sage Maker. Reizigers werkten samen met het Amazon Machine Learning Solutions Lab (nu bekend als de Generatief AI-innovatiecentrum) om dit raamwerk te ontwikkelen om use cases van luchtfotomodellen te ondersteunen en te verbeteren. Onze oplossing is gebaseerd op de DINO algoritme en gebruikt de SageMaker gedistribueerde parallelle gegevensbibliotheek (SMDDP) om de gegevens over meerdere GPU-instanties te verdelen. Wanneer de pre-training is voltooid, kunnen de DINO-beeldrepresentaties worden overgedragen naar een verscheidenheid aan downstream-taken. Dit initiatief leidde tot verbeterde modelprestaties binnen de Travellers Data & Analytics-ruimte.

Overzicht van de oplossing

Het tweestapsproces voor het vooraf trainen van vision-transformatoren en het overbrengen ervan naar stroomafwaartse taken onder supervisie wordt weergegeven in het volgende diagram.

In de volgende secties geven we een overzicht van de oplossing met behulp van satellietbeelden van de BigEarthNet-S2-gegevensset. We bouwen voort op de code in de DINO-opslagplaats.

Voorwaarden

Voordat u aan de slag gaat, heeft u toegang nodig tot een SageMaker notebook-instantie en een Amazon eenvoudige opslagservice (Amazone S3) emmer.

Bereid de BigEarthNet-S2-dataset voor

BigEarthNet-S2 is een benchmarkarchief dat 590,325 multispectrale beelden bevat die zijn verzameld door de Sentinel-2-satelliet. De afbeeldingen documenteren de landbedekking, of fysieke oppervlaktekenmerken, van tien Europese landen tussen juni 2017 en mei 2018. De soorten landbedekking in elke afbeelding, zoals weilanden of bossen, zijn geannoteerd volgens 19 labels. Hieronder volgen enkele voorbeelden van RGB-afbeeldingen en hun labels.

De eerste stap in onze workflow is het voorbereiden van de BigEarthNet-S2-dataset voor DINO-training en -evaluatie. We beginnen met het downloaden van de dataset van de terminal van onze SageMaker-notebookinstantie:

wget https://bigearth.net/downloads/BigEarthNet-S2-v1.0.tar.gz
tar -xvf BigEarthNet-S2-v1.0.tar.gz

De dataset heeft een grootte van ongeveer 109 GB. Elke afbeelding wordt opgeslagen in een eigen map en bevat 12 spectrale kanalen. Drie banden met een ruimtelijke resolutie van 60 m (pixelhoogte/-breedte van 60 meter) zijn ontworpen om aerosolen (B01), waterdamp (B09) en wolken (B10) te identificeren. Zes banden met een ruimtelijke resolutie van 20 m worden gebruikt om vegetatie te identificeren (B05, B06, B07, B8A) en onderscheid te maken tussen sneeuw, ijs en wolken (B11, B12). Drie banden met een ruimtelijke resolutie van 10 m helpen zichtbaar en nabij-infrarood licht op te vangen (B02, B03, B04, B8/B8A). Bovendien bevat elke map een JSON-bestand met de metadata van de afbeelding. Een gedetailleerde beschrijving van de gegevens vindt u in de BigEarthNet-gids.

Om tijdens de DINO-training statistische analyses van de gegevens uit te voeren en afbeeldingen te laden, verwerken we de individuele metadatabestanden tot een gemeenschappelijk geopandas Parquet-bestand. Dit kan worden gedaan met behulp van de BigEarthNet Common en de BigEarthNet GDF Builder helper pakketten:

python -m bigearthnet_gdf_builder.builder build-recommended-s2-parquet BigEarthNet-v1.0/

Het resulterende metadatabestand bevat de aanbevolen afbeeldingenset, die 71,042 afbeeldingen uitsluit die volledig bedekt zijn door seizoenssneeuw, wolken en wolkenschaduwen. Het bevat ook informatie over de acquisitiedatum, locatie, landbedekking en trein-, validatie- en testsplitsing voor elk beeld.

We slaan de BigEarthNet-S2-afbeeldingen en het metadatabestand op in een S3-bucket. Omdat we tijdens de DINO-training echte kleurenafbeeldingen gebruiken, uploaden we alleen de rode (B04), groene (B03) en blauwe (B02) banden:

aws s3 cp final_ben_s2.parquet s3://bigearthnet-s2-dataset/metadata/
aws s3 cp BigEarthNet-v1.0/ s3://bigearthnet-s2-dataset/data_rgb/ --recursive --exclude "*" --include "_B02.tif" --include "_B03.tif" --include "_B04.tif"

De dataset is ongeveer 48 GB groot en heeft de volgende structuur:

bigearthnet-s2-dataset/ Amazon S3 bucket
├── metadata/
│ └── final_ben_s2.parquet └── dataset_rgb/ ├── S2A_MSIL2A_20170613T101031_0_45/ │ └── S2A_MSIL2A_20170613T101031_0_45_B02.tif Blue channel │ └── S2A_MSIL2A_20170613T101031_0_45_B03.tif Green channel │ └── S2A_MSIL2A_20170613T101031_0_45_B04.tif Red channel

Train DINO-modellen met SageMaker

Nu onze dataset is geüpload naar Amazon S3, gaan we DINO-modellen trainen op BigEarthNet-S2. Zoals te zien is in de volgende afbeelding, geeft het DINO-algoritme verschillende globale en lokale uitsneden van een invoerbeeld door aan studenten- en docentennetwerken. Het studentennetwerk wordt geleerd om de output van het lerarennetwerk te evenaren door het cross-entropieverlies te minimaliseren. De leerling- en docentgewichten zijn verbonden door een exponentieel voortschrijdend gemiddelde (EMA).

We maken twee aanpassingen aan de originele DINO-code. Eerst maken we een aangepaste PyTorch-datasetklasse om de BigEarthNet-S2-afbeeldingen te laden. De code is oorspronkelijk geschreven om ImageNet-gegevens te verwerken en verwacht dat afbeeldingen per klasse worden opgeslagen. BigEarthNet-S2 is echter een dataset met meerdere labels waarbij elke afbeelding zich in een eigen submap bevindt. Onze datasetklasse laadt elke afbeelding met behulp van het bestandspad dat is opgeslagen in de metadata:

import pandas as pd
import rasterio
from PIL import Image
import torch
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms, utils OPTICAL_MAX_VALUE = 2000 LAND_COVER_LABELS = [ "Urban fabric", "Industrial or commercial units", "Arable land", "Permanent crops", "Pastures", "Complex cultivation patterns", "Land principally occupied by agriculture, with significant areas of natural vegetation", "Agro-forestry areas", "Broad-leaved forest", "Coniferous forest", "Mixed forest", "Natural grassland and sparsely vegetated areas", "Moors, heathland and sclerophyllous vegetation", "Transitional woodland, shrub", "Beaches, dunes, sands", "Inland wetlands", "Coastal wetlands", "Inland waters", "Marine waters",
] class BigEarthNetDataset(Dataset): """ PyTorch dataset class that loads the BigEarthNet-S2 images from a metadata file. Args: metadata_file: path to metadata file data_dir: directory where BigEarthNet-S2 data is located split: train, validation, or test split transform: transformations applied to the input image """ def __init__(self, metadata_file, data_dir, split="train", transform=None): # image file paths from metadata metadata = pd.read_parquet(metadata_file) self.metadata_split = metadata[metadata["original_split"] == split] self.data_dir = data_dir self.patch_names = self.metadata_split["name"].tolist() # one-hot-encode land cover labels multiclass_labels = self.metadata_split.new_labels.tolist() self.labels = self.get_multi_onehot_labels(multiclass_labels) # transforms self.transform = transform def __len__(self): """Return length of dataset.""" return len(self.metadata_split) def __getitem__(self, index): """Returns the image and label for a given index.""" patch_name = self.patch_names[index] file_path = os.path.join(self.data_dir, patch_name) # generate RGB image r_channel = rasterio.open(os.path.join(file_path, patch_name + "_B04.tif")).read(1) g_channel = rasterio.open(os.path.join(file_path, patch_name + "_B03.tif")).read(1) b_channel = rasterio.open(os.path.join(file_path, patch_name + "_B02.tif")).read(1) image = np.stack([r_channel, g_channel, b_channel], axis=2) image = image / OPTICAL_MAX_VALUE * 255 image = np.clip(image, 0, 225).astype(np.uint8) # apply image transforms image = Image.fromarray(image, mode="RGB") if self.transform is not None: image = self.transform(image) # load label label = self.labels[index] return image, label def get_multi_onehot_labels(self, multiclass_labels): """Convert BEN-19 labels to one-hot encoded vector.""" targets = torch.zeros([len(multiclass_labels), len(LAND_COVER_LABELS)]) for index, img_labels in enumerate(multiclass_labels): for label in img_labels: index_hot = LAND_COVER_LABELS.index(label) targets[index, index_hot] = 1. return targets

Deze datasetklasse wordt aangeroepen main_dino.py tijdens de training. Hoewel de code een functie bevat om de landbedekkingslabels eenmalig te coderen, worden deze labels niet gebruikt door het DINO-algoritme.

De tweede wijziging die we aanbrengen in de DINO-code is het toevoegen van ondersteuning voor SMDDP. We voegen de volgende code toe aan de init_distributed_mode functie in de util.py file:

init_distributed_mode function in the util.py file: def init_distributed_mode(args): if json.loads( os.environ.get('SM_FRAMEWORK_PARAMS', '{}')) .get('sagemaker_distributed_dataparallel_enabled', False) ): # launch training with SMDDP dist.init_process_group(backend='smddp') args.word_size = dist.get_world_size() args.gpu = int(os.environ['LOCAL_RANK'])

Met deze aanpassingen zijn we klaar om DINO-modellen te trainen op BigEarthNet-S2 met behulp van SageMaker. Om op meerdere GPU's of instanties te trainen, maken we een SageMaker PyTorch-schatter dat het DINO-trainingsscript, de afbeeldings- en metagegevensbestandspaden en de trainingshyperparameters opneemt:

import time
from sagemaker.pytorch import PyTorch # output bucket where final model artifacts are uploaded DINO_OUTPUT_BUCKET = 'dino-models' # paths on training instance sm_metadata_path = '/opt/ml/input/data/metadata' sm_data_path = '/opt/ml/input/data/train' sm_output_path = '/opt/ml/output/data' sm_checkpoint_path = '/opt/ml/checkpoints' # training job name
dino_base_job_name = f'dino-model-{int(time.time())}' # create SageMaker Estimator
estimator = PyTorch( base_job_name=dino_base_job_name, source_dir='path/to/aerial_featurizer', entry_point='main_dino.py', role=role, framework_version="1.12", py_version="py38", instance_count=1, instance_type="ml.p3.16xlarge", distribution = {'smdistributed':{'dataparallel':{'enabled': True}}}, volume_size=100, sagemaker_session=sagemaker_session, hyperparameters = { # hyperparameters passed to entry point script 'arch': 'vit_small', 'patch_size': 16, 'metadata_dir': sm_metadata_path, 'data_dir': sm_data_path, 'output_dir': sm_output_path, 'checkpoint_dir': sm_checkpoint_path, 'epochs': 100, 'saveckp_freq': 20, }, max_run=24*60*60, checkpoint_local_path = sm_checkpoint_path, checkpoint_s3_uri =f's3://{DINO_OUTPUT_BUCKET}/checkpoints/{base_job_name}', debugger_hook_config=False, )

Deze code specificeert dat we een klein vision-transformatormodel (21 miljoen parameters) gaan trainen met een patchgrootte van 16 voor 100 tijdperken. Het is best practice om een ​​nieuwe aan te maken checkpoint_s3_uri voor elke trainingstaak om de initiële downloadtijd van gegevens te verkorten. Omdat we SMDDP gebruiken, moeten we trainen op een ml.p3.16xlarge-, ml.p3dn.24xlarge- of ml.p4d.24xlarge-instantie. Dit komt omdat SMDDP alleen is ingeschakeld voor de grootste multi-GPU-instanties. Om te trainen op kleinere instantietypen zonder SMDDP, moet u het distribution en debugger_hook_config argumenten van de schatter.

Nadat we de SageMaker PyTorch Estimator hebben gemaakt, starten we de trainingstaak door de fit methode. We specificeren de ingevoerde trainingsgegevens met behulp van de Amazon S3 URI's voor de BigEarthNet-S2 metadata en afbeeldingen:

# call fit to begin training
estimator.fit( inputs={ 'metadata': 's3://bigearthnet-s2-dataset/metadata/', 'train': 's3://bigearthnet-s2-dataset/data_rgb/', }, wait=False
)

SageMaker start de instantie, kopieert het trainingsscript en de afhankelijkheden en begint met DINO-training. We kunnen de voortgang van de trainingstaak volgen vanuit onze Jupyter-notebook met behulp van de volgende opdrachten:

# monitor training
training_job_name = estimator.latest_training_job.name attached_estimator = PyTorch.attach(training_job_name)
attached_estimator.logs()

We kunnen ook instantiestatistieken bewaken en logbestanden bekijken op de SageMaker-console hieronder Training banen. In de volgende afbeeldingen zetten we het GPU-gebruik en de verliesfunctie uit voor een DINO-model dat is getraind op een ml.p3.16xlarge-instantie met een batchgrootte van 128.

Tijdens de training is het GPU-gebruik 83% van de ml.p3.16xlarge capaciteit (8 NVIDIA Tesla V100 GPU's) en het VRAM-gebruik is 85%. De verliesfunctie neemt gestaag af met elk tijdvak, wat aangeeft dat de resultaten van de leerling- en leraarnetwerken steeds meer op elkaar gaan lijken. In totaal duurt de training ongeveer 11 uur.

Breng leren over naar stroomafwaartse taken

Ons getrainde DINO-model kan worden overgedragen naar downstream-taken zoals beeldclassificatie of segmentatie. In deze sectie gebruiken we de vooraf getrainde DINO-functies om de landbedekkingsklassen voor afbeeldingen in de BigEarthNet-S2-dataset te voorspellen. Zoals weergegeven in het volgende diagram, trainen we een lineaire classificator met meerdere labels bovenop bevroren DINO-objecten. In dit voorbeeld is het invoerbeeld geassocieerd met akkerland en weiland.

De meeste code voor de lineaire classificatie is al aanwezig in de originele DINO-repository. Voor onze specifieke taak voeren we enkele aanpassingen door. Net als voorheen gebruiken we de aangepaste BigEarthNet-dataset om afbeeldingen te laden tijdens training en evaluatie. De labels voor de afbeeldingen zijn one-hot gecodeerd als 19-dimensionale binaire vectoren. Wij gebruiken de binaire cross-entropie voor de verliesfunctie en bereken de gemiddelde precisie om de prestaties van het model te evalueren.

Om de classifier te trainen, maken we een SageMaker PyTorch Estimator die het trainingsscript uitvoert, eval_linear.py. De trainingshyperparameters bevatten de details van de DINO-modelarchitectuur en het bestandspad voor het modelcontrolepunt:

# output bucket where final model artifacts are uploaded CLASSIFIER_OUTPUT_BUCKET = 'land-cover-classification' # DINO checkpoint name checkpoint = 'checkpoint.pth' # paths on training instance sm_dino_path = f'/opt/ml/input/data/dino_checkpoint' sm_dino_checkpoint = f'{sm_dino_path}/{checkpoint}' # training job name
classifier_base_job_name = f'linear-classifier-{int(time.time())}' # create Estimator estimator = PyTorch( base_job_name=classifier_base_job_name, source_dir='path/to/aerial_featurizer', entry_point = 'eval_linear.py', role=role, framework_version='1.12', py_version='py38', instance_count=1, instance_type='ml.p3.2xlarge', sagemaker_session=sagemaker_session, hyperparameters = { # hyperparameters passed to entry point script 'arch': 'vit_small', 'pretrained_weights': sm_dino_checkpoint, 'epochs': 50, 'data_dir': sm_data_path, 'metadata_dir': sm_metadata_path, 'output_dir': sm_checkpoint_path, 'num_labels': 19, }, max_run=1*60*60, checkpoint_local_path = sm_checkpoint_path, checkpoint_s3_uri =f's3://{CLASSIFIER_OUTPUT_BUCKET}/checkpoints/{base_job_name}',
)

We starten de trainingstaak met behulp van de fit methode, die de Amazon S3-locaties van de BigEarthNet-S2-metadata en trainingsafbeeldingen en het DINO-modelcontrolepunt levert:

# call fit to begin training
estimator.fit( inputs={ 'metadata': 's3://bigearthnet-s2-dataset/metadata/', 'dataset': 's3://bigearthnet-s2-dataset/data_rgb/', 'dino_checkpoint': f's3://bigearthnet-s2-dataset/dino-models/checkpoints/{dino_base_job_name}', }, wait=False
)

Wanneer de training is voltooid, kunnen we gevolgtrekkingen uitvoeren op de BigEarthNet-S2-testset met behulp van SageMaker batch-transformatie or SageMaker-verwerking. In de volgende tabel vergelijken we de gemiddelde precisie van het lineaire model op testsetafbeeldingen met behulp van twee verschillende DINO-afbeeldingsrepresentaties. Het eerste model, ViT-S/16 (ImageNet), is het controlepunt van de kleine vision-transformator dat is opgenomen in de DINO-repository en vooraf is getraind met behulp van naar voren gerichte afbeeldingen in de ImageNet-dataset. Het tweede model, ViT-S/16 (BigEarthNet-S2), is het model dat we hebben gemaakt door vooraf te trainen op overheadbeelden.

We vinden dat het DINO-model dat vooraf is getraind op BigEarthNet-S2 beter overgaat in de classificatietaak van landbedekking dan het DINO-model dat vooraf is getraind op ImageNet, wat resulteert in een toename van 6.7% in de gemiddelde precisie.

Opruimen

Na het voltooien van de DINO-training en het leren overdragen, kunnen we onze middelen opschonen om te voorkomen dat er kosten in rekening worden gebracht. Wij stop of verwijder onze notebookinstantie en verwijder alle ongewenste gegevens of modelartefacten van Amazon S3.

Conclusie

Dit bericht liet zien hoe DINO-modellen kunnen worden getraind op overheadbeelden met behulp van SageMaker. We gebruikten SageMaker PyTorch Estimators en SMDDP om weergaven van BigEarthNet-S2-afbeeldingen te genereren zonder dat er expliciete labels nodig waren. Vervolgens hebben we de DINO-functies overgebracht naar een stroomafwaartse beeldclassificatietaak, waarbij de landbedekkingsklasse van BigEarthNet-S2-beelden moest worden voorspeld. Voor deze taak leverde pre-training op satellietbeelden een toename van 6.7% op in de gemiddelde precisie ten opzichte van pre-training op ImageNet.

U kunt deze oplossing gebruiken als sjabloon voor het trainen van DINO-modellen op grootschalige, niet-gelabelde datasets van lucht- en satellietbeelden. Bekijk de volgende bronnen voor meer informatie over DINO en het bouwen van modellen op SageMaker:

Over de auteurs

Ben Veasey is een Senior Associate Data Scientist bij Travellers, werkzaam binnen het AI & Automation Accelerator-team. Met een grondige kennis van innovatieve AI-technologieën, waaronder computervisie, natuurlijke taalverwerking en generatieve AI, zet Ben zich in om de acceptatie van deze technologieën te versnellen om bedrijfsprocessen te optimaliseren en de efficiëntie bij Travellers te stimuleren.

Jeremy Andersen is Director & Data Scientist bij Travellers in het AI & Automation Accelerator-team. Hij is geïnteresseerd in het oplossen van zakelijke problemen met de nieuwste AI en deep learning-technieken, waaronder grote taalmodellen, fundamentele beeldmodellen en generatieve AI. Voordat hij bij Travellers kwam, behaalde Jeremy een doctoraat in moleculaire biofysica aan de Johns Hopkins University en studeerde hij ook evolutionaire biochemie. Buiten zijn werk kun je hem zien rennen, houtbewerken of zijn tuin opnieuw inrichten.

Jordan Knight is een Senior Data Scientist die voor Travellers werkt op de afdeling Business Insurance Analytics & Research. Zijn passie is het oplossen van uitdagende real-world computer vision-problemen en het verkennen van nieuwe state-of-the-art methoden om dit te doen. Hij heeft een bijzondere interesse in de sociale impact van ML-modellen en hoe we modelleringsprocessen kunnen blijven verbeteren om ML-oplossingen te ontwikkelen die voor iedereen rechtvaardig zijn. Jordan is afgestudeerd aan het MIT met een master in Business Analytics. In zijn vrije tijd kun je hem rotsklimmen, wandelen of zijn ietwat rudimentaire kookkunsten blijven ontwikkelen.

Juni Li is een datawetenschapper bij het Artificial Intelligence-team van Travellers' Business Insurance, waar ze het werk in het AI-beeldportfolio leidt en coördineert. Ze is gepassioneerd door het implementeren van innovatieve AI-oplossingen die substantiële waarde toevoegen aan de zakelijke partners en belanghebbenden. Haar werk is een integraal onderdeel geweest van het omzetten van complexe zakelijke uitdagingen in kansen door gebruik te maken van geavanceerde AI-technologieën.

Sourav Bhabesh is een Senior Applied Scientist bij AWS Titan Labs, waar hij de mogelijkheden en functies van het Foundational Model (FM) bouwt. Zijn specialiteit is Natural Language Processing (NLP) en hij heeft een passie voor deep learning. Naast zijn werk houdt hij van boeken lezen en reizen.

Laura Koelowski is Applied Scientist bij het Generative AI Innovation Center van Amazon, waar ze nauw samenwerkt met klanten om generatieve AI-oplossingen te bouwen. In haar vrije tijd verkent Laura graag nieuwe plekken op de fiets.

Andrew Ango is Sr. Machine Learning Engineer bij AWS. Naast het helpen van klanten bij het bouwen van AI/ML-oplossingen, houdt hij van watersporten, squash en het bekijken van reis- en foodvlogs.

Mehdi Noori is Applied Science Manager bij het Generative AI Innovation Center. Met een passie voor het overbruggen van technologie en innovatie, helpt hij AWS-klanten bij het ontsluiten van het potentieel van generatieve AI, het omzetten van potentiële uitdagingen in kansen voor snelle experimenten en innovatie door zich te concentreren op schaalbaar, meetbaar en impactvol gebruik van geavanceerde AI-technologieën, en het pad te stroomlijnen naar productie.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. Automotive / EV's, carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• ChartPrime. Verhoog uw handelsspel met ChartPrime. Toegang hier.
• BlockOffsets. Eigendom voor milieucompensatie moderniseren. Toegang hier.
• Bron: https://aws.amazon.com/blogs/machine-learning/train-self-supervised-vision-transformers-on-overhead-imagery-with-amazon-sagemaker/