Det här är ett gästblogginlägg som skrivits tillsammans med Ben Veasey, Jeremy Anderson, Jordan Knight och June Li från Travelers.

Satellit- och flygbilder ger insikt i ett brett spektrum av problem, inklusive precisionsjordbruk, försäkringsriskbedömning, stadsutveckling och katastrofhantering. Utbildning av maskininlärningsmodeller (ML) för att tolka dessa data är dock flaskhalsade av kostsamma och tidskrävande mänskliga anteckningsinsatser. Ett sätt att övervinna denna utmaning är genom självövervakat lärande (SSL). Genom att träna på stora mängder omärkt bilddata lär sig självövervakade modeller bildrepresentationer som kan överföras till nedströmsuppgifter, såsom bildklassificering eller segmentering. Detta tillvägagångssätt producerar bildrepresentationer som generaliserar väl till osynliga data och minskar mängden märkt data som krävs för att bygga prestanda nedströmsmodeller.

I det här inlägget visar vi hur man tränar självövervakade syntransformatorer på överliggande bilder med hjälp av Amazon SageMaker. Resenärer samarbetade med Amazon Machine Learning Solutions Lab (nu känt som Generativt AI Innovation Center) för att utveckla detta ramverk för att stödja och förbättra användningsfall för flygbilder. Vår lösning är baserad på DINO algoritm och använder SageMaker distribuerade dataparallellt bibliotek (SMDDP) för att dela upp data över flera GPU-instanser. När förträningen är klar kan DINO-bildrepresentationerna överföras till en mängd olika nedströmsuppgifter. Detta initiativ ledde till förbättrade modellprestanda inom Traveller Data & Analytics-området.

Översikt över lösningen

Tvåstegsprocessen för att förträna syntransformatorer och överföra dem till övervakade nedströmsuppgifter visas i följande diagram.

I följande avsnitt ger vi en genomgång av lösningen med hjälp av satellitbilder från BigEarthNet-S2 dataset. Vi bygger på koden som finns i DINO-förvaret.

Förutsättningar

Innan du börjar behöver du tillgång till en SageMaker anteckningsbok instans och en Amazon enkel lagringstjänst (Amazon S3) skopa.

Förbered BigEarthNet-S2-datauppsättningen

BigEarthNet-S2 är ett benchmark-arkiv som innehåller 590,325 2 multispektrala bilder som samlats in av Sentinel-2017-satelliten. Bilderna dokumenterar marktäcket, eller fysiska ytegenskaper, i tio europeiska länder mellan juni 2018 och maj 19. Typerna av marktäcke i varje bild, som betesmarker eller skogar, är kommenterade enligt XNUMX etiketter. Följande är några exempel på RGB-bilder och deras etiketter.

Det första steget i vårt arbetsflöde är att förbereda BigEarthNet-S2-datauppsättningen för DINO-utbildning och utvärdering. Vi börjar med att ladda ner datamängden från terminalen i vår SageMaker-anteckningsbokinstans:

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

Datauppsättningen har en storlek på cirka 109 GB. Varje bild lagras i sin egen mapp och innehåller 12 spektralkanaler. Tre band med 60 m rumslig upplösning (60 meter pixel höjd/bredd) är designade för att identifiera aerosoler (B01), vattenånga (B09) och moln (B10). Sex band med 20 m rumslig upplösning används för att identifiera vegetation (B05, B06, B07, B8A) och skilja mellan snö, is och moln (B11, B12). Tre band med 10 m rumslig upplösning hjälper till att fånga synligt och nära-infrarött ljus (B02, B03, B04, B8/B8A). Dessutom innehåller varje mapp en JSON-fil med bildens metadata. En detaljerad beskrivning av uppgifterna finns i BigEarthNet Guide.

För att utföra statistiska analyser av data och ladda bilder under DINO-träning, bearbetar vi de enskilda metadatafilerna till en gemensam geopandas Parquet-fil. Detta kan göras med hjälp av BigEarthNet Common och BigEarthNet GDF Builder hjälparpaket:

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

Den resulterande metadatafilen innehåller den rekommenderade bilduppsättningen, som exkluderar 71,042 XNUMX bilder som är helt täckta av årstidens snö, moln och molnskuggor. Den innehåller också information om förvärvsdatum, plats, marktäcke och tåg, validering och testdelning för varje bild.

Vi lagrar BigEarthNet-S2-bilderna och metadatafilen i en S3-hink. Eftersom vi använder äkta färgbilder under DINO-träning laddar vi bara upp de röda (B04), gröna (B03) och blå (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"

Datauppsättningen är cirka 48 GB stor och har följande struktur:

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

Träna DINO-modeller med SageMaker

Nu när vår datauppsättning har laddats upp till Amazon S3 går vi över till att träna DINO-modeller på BigEarthNet-S2. Som visas i följande figur skickar DINO-algoritmen olika globala och lokala skördar av en indatabild till elev- och lärarnätverk. Elevnätverket lärs matcha utdata från lärarnätverket genom att minimera korsentropiförlusten. Elev- och lärarevikterna är sammankopplade med ett exponentiellt glidande medelvärde (EMA).

Vi gör två modifieringar av den ursprungliga DINO-koden. Först skapar vi en anpassad PyTorch-datauppsättningsklass för att ladda BigEarthNet-S2-bilderna. Koden skrevs ursprungligen för att bearbeta ImageNet-data och förväntar sig att bilder ska lagras klassvis. BigEarthNet-S2 är dock en datauppsättning med flera etiketter där varje bild finns i sin egen undermapp. Vår datauppsättningsklass laddar varje bild med hjälp av filsökvägen som lagras i 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

Denna datauppsättningsklass kallas in main_dino.py under träning. Även om koden innehåller en funktion för att en-hot-koda marktäckningsetiketterna, används dessa etiketter inte av DINO-algoritmen.

Den andra förändringen vi gör i DINO-koden är att lägga till stöd för SMDDP. Vi lägger till följande kod till init_distributed_mode funktion i util.py fil:

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'])

Med dessa justeringar är vi redo att träna DINO-modeller på BigEarthNet-S2 med SageMaker. För att träna på flera GPU:er eller instanser skapar vi en SageMaker PyTorch Estimator som matar in DINO-träningsskriptet, bild- och metadatafilens sökvägar och träningshyperparametrarna:

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

Den här koden anger att vi kommer att träna en liten visiontransformatormodell (21 miljoner parametrar) med en patchstorlek på 16 för 100 epoker. Det är bästa praxis att skapa en ny checkpoint_s3_uri för varje utbildningsjobb för att minska den initiala nedladdningstiden för data. Eftersom vi använder SMDDP måste vi träna på en ml.p3.16xlarge, ml.p3dn.24xlarge eller ml.p4d.24xlarge instans. Detta beror på att SMDDP endast är aktiverat för de största multi-GPU-instanserna. För att träna på mindre instanstyper utan SMDDP måste du ta bort distribution och debugger_hook_config argument från skattaren.

Efter att vi har skapat SageMaker PyTorch Estimator lanserar vi träningsjobbet genom att ringa till fit metod. Vi specificerar indataträningsdata med hjälp av Amazon S3 URI:er för BigEarthNet-S2 metadata och bilder:

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

SageMaker snurrar upp instansen, kopierar träningsskriptet och beroenden och börjar DINO-träning. Vi kan övervaka hur träningsjobbet fortskrider från vår Jupyter-anteckningsbok med hjälp av följande kommandon:

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

Vi kan också övervaka instansmätningar och visa loggfiler på SageMaker-konsolen under Träningsjobb. I följande figurer plottar vi GPU-användnings- och förlustfunktionen för en DINO-modell tränad på en ml.p3.16xlarge-instans med en batchstorlek på 128.

Under träning är GPU-användningen 83 % av ml.p3.16xlarge-kapaciteten (8 NVIDIA Tesla V100 GPU) och VRAM-användningen är 85 %. Förlustfunktionen minskar stadigt för varje epok, vilket indikerar att resultaten från student- och lärarnätverken blir mer lika. Totalt tar träningen cirka 11 timmar.

Överför lärande till nedströmsuppgifter

Vår utbildade DINO-modell kan överföras till nedströmsuppgifter som bildklassificering eller segmentering. I det här avsnittet använder vi de förtränade DINO-funktionerna för att förutsäga marktäckningsklasserna för bilder i BigEarthNet-S2-datauppsättningen. Som visas i följande diagram tränar vi en linjär klassificerare med flera etiketter ovanpå frusna DINO-funktioner. I det här exemplet är ingångsbilden associerad med åkermark och betesmarker.

Det mesta av koden för den linjära klassificeraren finns redan på plats i det ursprungliga DINO-förrådet. Vi gör några justeringar för vår specifika uppgift. Som tidigare använder vi den anpassade BigEarthNet-datauppsättningen för att ladda bilder under träning och utvärdering. Etiketterna för bilderna är one-hot-kodade som 19-dimensionella binära vektorer. Vi använder binär korsentropi för förlustfunktionen och beräkna genomsnittlig precision för att utvärdera modellens prestanda.

För att träna klassificeraren skapar vi en SageMaker PyTorch Estimator som kör träningsskriptet, eval_linear.py. Träningshyperparametrarna inkluderar detaljerna om DINO-modellarkitekturen och filsökvägen för modellens kontrollpunkt:

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

Vi börjar träningsjobbet med hjälp av fit metod, tillhandahåller Amazon S3-platserna för BigEarthNet-S2-metadata och träningsbilder och DINO-modellens kontrollpunkt:

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

När utbildningen är klar kan vi göra slutsatser om BigEarthNet-S2 testset med hjälp av SageMaker batch-transformation or SageMaker-bearbetning. I följande tabell jämför vi den linjära modellens genomsnittliga precision på testbilder med två olika DINO-bildrepresentationer. Den första modellen, ViT-S/16 (ImageNet), är den lilla kontrollpunkten för visiontransformatorer som ingår i DINO-förvaret och som var förtränad med hjälp av framvända bilder i ImageNet-datauppsättningen. Den andra modellen, ViT-S/16 (BigEarthNet-S2), är den modell vi producerade genom att förträna på överliggande bilder.

Vi finner att DINO-modellen förutbildad på BigEarthNet-S2 överförs bättre till marktäckningsklassificeringsuppgiften än DINO-modellen förutbildad på ImageNet, vilket resulterar i en 6.7 % ökning av den genomsnittliga precisionen.

Städa upp

Efter att ha slutfört DINO-utbildning och överföringsinlärning kan vi sanera våra resurser för att undvika avgifter. Vi stoppa eller ta bort vår anteckningsbok-instans och ta bort alla oönskade data eller modellartefakter från Amazon S3.

Slutsats

Det här inlägget demonstrerade hur man tränar DINO-modeller på överliggande bilder med SageMaker. Vi använde SageMaker PyTorch Estimators och SMDDP för att generera representationer av BigEarthNet-S2-bilder utan behov av explicita etiketter. Vi överförde sedan DINO-funktionerna till en nedströms bildklassificeringsuppgift, som innebar att förutsäga landtäckningsklassen för BigEarthNet-S2-bilder. För denna uppgift gav förträning på satellitbilder en ökning med 6.7 % i genomsnittlig precision jämfört med förträning på ImageNet.

Du kan använda den här lösningen som en mall för att träna DINO-modeller på storskaliga, omärkta flyg- och satellitbildersdatauppsättningar. För att lära dig mer om DINO och att bygga modeller på SageMaker, kolla in följande resurser:

Om författarna

Ben Veasey är Senior Associate Data Scientist på Travelers, som arbetar inom AI & Automation Accelerator-teamet. Med en djup förståelse för innovativ AI-teknik, inklusive datorseende, naturlig språkbehandling och generativ AI, är Ben dedikerad till att påskynda införandet av dessa tekniker för att optimera affärsprocesser och öka effektiviteten hos Travelers.

Jeremy Andersson är Director & Data Scientist på Travelers på AI & Automation Accelerator-teamet. Han är intresserad av att lösa affärsproblem med de senaste AI- och djupinlärningsteknikerna inklusive stora språkmodeller, grundläggande bildmodeller och generativ AI. Innan han började på resenärer tog Jeremy en doktorsexamen i molekylär biofysik från Johns Hopkins University och studerade även evolutionär biokemi. Utanför jobbet kan du hitta honom springa, träbearbeta eller omvilja sin trädgård.

Jordan Knight är en Senior Data Scientist som arbetar för resenärer på Business Insurance Analytics & Research Department. Hans passion är att lösa utmanande verkliga datorseendeproblem och att utforska nya toppmoderna metoder för att göra det. Han har ett särskilt intresse för den sociala påverkan av ML-modeller och hur vi kan fortsätta att förbättra modelleringsprocesser för att utveckla ML-lösningar som är rättvisa för alla. Jordan tog examen från MIT med en magisterexamen i Business Analytics. På fritiden kan du hitta honom som antingen klättrar, vandrar eller fortsätter att utveckla sina lite rudimentära matlagningsfärdigheter.

juni Li är datavetare på Travellers's Business Insurances Artificiell Intelligens-team, där hon leder och koordinerar arbetet i AI-bildportföljen. Hon brinner för att implementera innovativa AI-lösningar som ger betydande värde till affärspartners och intressenter. Hennes arbete har varit avgörande för att omvandla komplexa affärsutmaningar till möjligheter genom att utnyttja banbrytande AI-teknik.

Sourav Bhabesh är senior tillämpad forskare vid AWS Titan Labs, där han bygger FM-funktioner och -funktioner. Hans specialitet är Natural Language Processing (NLP) och brinner för djupinlärning. Utanför jobbet tycker han om att läsa böcker och att resa.

Laura Kulowski är en tillämpad forskare på Amazons Generative AI Innovation Center, där hon arbetar nära kunder för att bygga generativa AI-lösningar. På fritiden tycker Laura om att utforska nya platser på cykel.

Andrew Ang är Sr. Machine Learning Engineer på AWS. Förutom att hjälpa kunder att bygga AI/ML-lösningar tycker han om vattensporter, squash och tittar på rese- och matvloggar.

Mehdi Noori är en tillämpad vetenskapschef på Generative AI Innovation Center. Med en passion för att överbrygga teknik och innovation hjälper han AWS-kunder att låsa upp potentialen hos generativ AI, omvandla potentiella utmaningar till möjligheter för snabba experiment och innovation genom att fokusera på skalbar, mätbar och effektfull användning av avancerad AI-teknik och effektivisera vägen. till produktion.

• SEO-drivet innehåll och PR-distribution. Bli förstärkt idag.
• PlatoData.Network Vertical Generative Ai. Styrka dig själv. Tillgång här.
• PlatoAiStream. Web3 Intelligence. Kunskap förstärkt. Tillgång här.
• Platoesg. Fordon / elbilar, Kol, CleanTech, Energi, Miljö, Sol, Avfallshantering. Tillgång här.
• PlatoHealth. Biotech och kliniska prövningar Intelligence. Tillgång här.
• ChartPrime. Höj ditt handelsspel med ChartPrime. Tillgång här.
• BlockOffsets. Modernisera miljökompensation ägande. Tillgång här.
• Källa: https://aws.amazon.com/blogs/machine-learning/train-self-supervised-vision-transformers-on-overhead-imagery-with-amazon-sagemaker/