Il s'agit d'un article de blog invité co-écrit avec Ben Veasey, Jeremy Anderson, Jordan Knight et June Li de Travelers.

Les images satellitaires et aériennes donnent un aperçu d'un large éventail de problèmes, notamment l'agriculture de précision, l'évaluation des risques d'assurance, le développement urbain et la réponse aux catastrophes. Cependant, la formation de modèles d'apprentissage automatique (ML) pour interpréter ces données est entravée par des efforts d'annotation humaine coûteux et chronophages. Une façon de surmonter ce défi consiste à apprentissage auto-supervisé (SSL). En s'entraînant sur de grandes quantités de données d'images non étiquetées, les modèles auto-supervisés apprennent des représentations d'images qui peuvent être transférées vers des tâches en aval, telles que la classification ou la segmentation d'images. Cette approche produit des représentations d'images qui se généralisent bien aux données invisibles et réduit la quantité de données étiquetées nécessaires pour créer des modèles en aval performants.

Dans cet article, nous montrons comment former des transformateurs de vision auto-supervisés sur l'imagerie aérienne à l'aide de Amazon Sage Maker. Les voyageurs ont collaboré avec Amazon Machine Learning Solutions Lab (maintenant connu sous le nom de Centre d'innovation en IA générative) pour développer ce cadre afin de prendre en charge et d'améliorer les cas d'utilisation de modèles d'imagerie aérienne. Notre solution est basée sur la DINO algorithme et utilise le Bibliothèque parallèle de données distribuées SageMaker (SMDDP) pour répartir les données sur plusieurs instances GPU. Lorsque la pré-formation est terminée, les représentations d'images DINO peuvent être transférées vers une variété de tâches en aval. Cette initiative a permis d'améliorer les performances des modèles au sein de l'espace Travelers Data & Analytics.

Présentation de la solution

Le processus en deux étapes pour pré-former les transformateurs de vision et les transférer vers des tâches supervisées en aval est illustré dans le diagramme suivant.

Dans les sections suivantes, nous fournissons une présentation de la solution à l'aide d'images satellites du Jeu de données BigEarthNet-S2. Nous nous appuyons sur le code fourni dans le Référentiel DINO.

Pré-requis

Avant de commencer, vous devez avoir accès à un Instance de notebook SageMaker et le Service de stockage simple Amazon (Amazon S3) seau.

Préparer le jeu de données BigEarthNet-S2

BigEarthNet-S2 est une archive de référence qui contient 590,325 2 images multispectrales collectées par le satellite Sentinel-2017. Les images documentent la couverture terrestre, ou les caractéristiques physiques de la surface, de dix pays européens entre juin 2018 et mai 19. Les types de couverture terrestre de chaque image, tels que les pâturages ou les forêts, sont annotés selon XNUMX étiquettes. Voici quelques exemples d'images RVB et leurs étiquettes.

La première étape de notre flux de travail consiste à préparer l'ensemble de données BigEarthNet-S2 pour la formation et l'évaluation DINO. Nous commençons par télécharger le jeu de données depuis le terminal de notre instance de notebook SageMaker :

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

Le jeu de données a une taille d'environ 109 Go. Chaque image est stockée dans son propre dossier et contient 12 canaux spectraux. Trois bandes avec une résolution spatiale de 60 m (hauteur/largeur de pixel de 60 mètres) sont conçues pour identifier les aérosols (B01), la vapeur d'eau (B09) et les nuages ​​(B10). Six bandes avec une résolution spatiale de 20 m sont utilisées pour identifier la végétation (B05, B06, B07, B8A) et distinguer la neige, la glace et les nuages ​​(B11, B12). Trois bandes avec une résolution spatiale de 10 m aident à capturer la lumière visible et proche infrarouge (B02, B03, B04, B8/B8A). De plus, chaque dossier contient un fichier JSON avec les métadonnées de l'image. Une description détaillée des données est fournie dans le Guide BigEarthNet.

Pour effectuer des analyses statistiques des données et charger des images pendant la formation DINO, nous traitons les fichiers de métadonnées individuels dans un fichier commun de géopandas Parquet. Cela peut être fait en utilisant BigEarthNet Common et BigEarthNet GDF Builder packages d'assistance:

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

Le fichier de métadonnées résultant contient l'ensemble d'images recommandé, qui exclut 71,042 XNUMX images entièrement couvertes par la neige saisonnière, les nuages ​​et les ombres des nuages. Il contient également des informations sur la date d'acquisition, l'emplacement, la couverture terrestre et le train, la validation et la répartition des tests pour chaque image.

Nous stockons les images et le fichier de métadonnées BigEarthNet-S2 dans un compartiment S3. Étant donné que nous utilisons des images en vraies couleurs pendant la formation DINO, nous téléchargeons uniquement les bandes rouge (B04), verte (B03) et bleue (B02) :

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"

L'ensemble de données a une taille d'environ 48 Go et a la structure suivante :

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

Former des modèles DINO avec SageMaker

Maintenant que notre ensemble de données a été téléchargé sur Amazon S3, nous passons à la formation de modèles DINO sur BigEarthNet-S2. Comme le montre la figure suivante, l'algorithme DINO transmet différentes cultures globales et locales d'une image d'entrée aux réseaux d'élèves et d'enseignants. Le réseau étudiant apprend à correspondre à la sortie du réseau enseignant en minimisant la perte d'entropie croisée. Les poids des élèves et des enseignants sont reliés par une moyenne mobile exponentielle (EMA).

Nous apportons deux modifications au code DINO original. Tout d'abord, nous créons une classe de jeu de données PyTorch personnalisée pour charger les images BigEarthNet-S2. Le code a été initialement écrit pour traiter les données ImageNet et s'attend à ce que les images soient stockées par classe. BigEarthNet-S2, cependant, est un ensemble de données multi-étiquettes où chaque image réside dans son propre sous-dossier. Notre classe d'ensemble de données charge chaque image en utilisant le chemin du fichier stocké dans les métadonnées :

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

Cette classe d'ensemble de données est appelée dans main_dino.py pendant la formation. Bien que le code comprenne une fonction permettant d'encoder à chaud les étiquettes de couverture du sol, ces étiquettes ne sont pas utilisées par l'algorithme DINO.

La deuxième modification que nous apportons au code DINO consiste à ajouter la prise en charge de SMDDP. Nous ajoutons le code suivant au init_distributed_mode fonction de l' util.py fichier:

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

Avec ces ajustements, nous sommes prêts à former des modèles DINO sur BigEarthNet-S2 à l'aide de SageMaker. Pour former sur plusieurs GPU ou instances, nous créons un Estimateur SageMaker PyTorch qui ingère le script de formation DINO, les chemins d'accès aux fichiers d'image et de métadonnées et les hyperparamètres de formation :

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

Ce code spécifie que nous allons former un petit modèle de transformateur de vision (21 millions de paramètres) avec une taille de patch de 16 pour 100 époques. Il est recommandé de créer un nouveau checkpoint_s3_uri pour chaque tâche de formation afin de réduire le temps de téléchargement initial des données. Étant donné que nous utilisons SMDDP, nous devons nous entraîner sur une instance ml.p3.16xlarge, ml.p3dn.24xlarge ou ml.p4d.24xlarge. En effet, SMDDP n'est activé que pour les plus grandes instances multi-GPU. Pour vous entraîner sur des types d'instances plus petits sans SMDDP, vous devrez supprimer le distribution et les debugger_hook_config arguments de l'estimateur.

Après avoir créé l'estimateur SageMaker PyTorch, nous lançons le travail de formation en appelant le fit méthode. Nous spécifions les données de formation d'entrée à l'aide des URI Amazon S3 pour les métadonnées et les images BigEarthNet-S2 :

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

SageMaker lance l'instance, copie le script de formation et les dépendances, et commence la formation DINO. Nous pouvons surveiller la progression de la tâche d'entraînement à partir de notre notebook Jupyter à l'aide des commandes suivantes :

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

Nous pouvons également surveiller les métriques d'instance et afficher les fichiers journaux sur la console SageMaker sous Emplois de formation. Dans les figures suivantes, nous traçons la fonction d'utilisation et de perte du GPU pour un modèle DINO formé sur une instance ml.p3.16xlarge avec une taille de lot de 128.

Pendant l'entraînement, l'utilisation du GPU est de 83 % de la capacité ml.p3.16xlarge (8 GPU NVIDIA Tesla V100) et l'utilisation de la VRAM est de 85 %. La fonction de perte diminue régulièrement à chaque époque, ce qui indique que les sorties des réseaux d'élèves et d'enseignants deviennent plus similaires. Au total, la formation dure environ 11 heures.

Transférer l'apprentissage vers les tâches en aval

Notre modèle DINO formé peut être transféré à des tâches en aval telles que la classification ou la segmentation d'images. Dans cette section, nous utilisons les fonctionnalités DINO pré-formées pour prédire les classes de couverture terrestre pour les images du jeu de données BigEarthNet-S2. Comme illustré dans le diagramme suivant, nous formons un classificateur linéaire multi-étiquettes au-dessus des fonctionnalités DINO figées. Dans cet exemple, l'image d'entrée est associée aux couvertures des terres arables et des pâturages.

La majeure partie du code du classificateur linéaire est déjà en place dans le référentiel DINO d'origine. Nous faisons quelques ajustements pour notre tâche spécifique. Comme auparavant, nous utilisons l'ensemble de données BigEarthNet personnalisé pour charger des images pendant la formation et l'évaluation. Les étiquettes des images sont codées à chaud sous forme de vecteurs binaires à 19 dimensions. Nous utilisons le entropie croisée binaire pour la fonction de perte et calculer la précision moyenne pour évaluer les performances du modèle.

Pour former le classificateur, nous créons un estimateur SageMaker PyTorch qui exécute le script de formation, eval_linear.py. Les hyperparamètres de formation incluent les détails de l'architecture du modèle DINO et le chemin du fichier pour le point de contrôle du modèle :

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

Nous commençons le travail de formation en utilisant le fit méthode, fournissant les emplacements Amazon S3 des métadonnées et des images de formation BigEarthNet-S2 et le point de contrôle du modèle DINO :

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

Lorsque la formation est terminée, nous pouvons effectuer une inférence sur l'ensemble de test BigEarthNet-S2 en utilisant Transformation par lots SageMaker or Traitement SageMaker. Dans le tableau suivant, nous comparons la précision moyenne du modèle linéaire sur des images de jeu de test en utilisant deux représentations d'image DINO différentes. Le premier modèle, ViT-S/16 (ImageNet), est le petit point de contrôle du transformateur de vision inclus dans le référentiel DINO qui a été pré-formé à l'aide d'images de face dans l'ensemble de données ImageNet. Le deuxième modèle, ViT-S/16 (BigEarthNet-S2), est le modèle que nous avons produit par pré-formation sur l'imagerie aérienne.

Nous constatons que le modèle DINO pré-formé sur BigEarthNet-S2 se transfère mieux à la tâche de classification de la couverture terrestre que le modèle DINO pré-formé sur ImageNet, ce qui entraîne une augmentation de 6.7 % de la précision moyenne.

Nettoyer

Après avoir terminé la formation DINO et l'apprentissage par transfert, nous pouvons nettoyer nos ressources pour éviter d'encourir des frais. Nous arrêter ou supprimer notre instance de bloc-notes et les supprimer toutes les données indésirables ou les artefacts de modèle d'Amazon S3.

Conclusion

Cet article a montré comment former des modèles DINO sur l'imagerie aérienne à l'aide de SageMaker. Nous avons utilisé les estimateurs SageMaker PyTorch et SMDDP afin de générer des représentations d'images BigEarthNet-S2 sans avoir besoin d'étiquettes explicites. Nous avons ensuite transféré les caractéristiques DINO à une tâche de classification d'images en aval, qui impliquait de prédire la classe de couverture terrestre des images BigEarthNet-S2. Pour cette tâche, la pré-formation sur l'imagerie satellitaire a produit une augmentation de 6.7 % de la précision moyenne par rapport à la pré-formation sur ImageNet.

Vous pouvez utiliser cette solution comme modèle pour former des modèles DINO sur des ensembles de données d'imagerie aérienne et satellite à grande échelle et non étiquetées. Pour en savoir plus sur DINO et la création de modèles sur SageMaker, consultez les ressources suivantes :

À propos des auteurs

Ben Veasey est Senior Associate Data Scientist chez Travelers, travaillant au sein de l'équipe AI & Automation Accelerator. Avec une compréhension approfondie des technologies d'IA innovantes, y compris la vision par ordinateur, le traitement du langage naturel et l'IA générative, Ben se consacre à accélérer l'adoption de ces technologies pour optimiser les processus commerciaux et accroître l'efficacité chez Travelers.

Jérémy Anderson est directeur et scientifique des données chez Travelers au sein de l'équipe AI & Automation Accelerator. Il s'intéresse à la résolution de problèmes commerciaux avec les dernières techniques d'IA et d'apprentissage en profondeur, y compris les grands modèles de langage, les modèles d'imagerie fondamentaux et l'IA générative. Avant Travelers, Jeremy a obtenu un doctorat en biophysique moléculaire de l'Université Johns Hopkins et a également étudié la biochimie évolutive. En dehors du travail, vous pouvez le trouver en train de courir, de travailler le bois ou de ré-ensauvager son jardin.

Chevalier de la Jordanie est un scientifique principal des données travaillant pour les voyageurs au sein du département d'analyse et de recherche en assurance des entreprises. Sa passion est de résoudre des problèmes de vision par ordinateur difficiles dans le monde réel et d'explorer de nouvelles méthodes de pointe pour le faire. Il s'intéresse particulièrement à l'impact social des modèles ML et à la manière dont nous pouvons continuer à améliorer les processus de modélisation pour développer des solutions ML équitables pour tous. Jordan est diplômé du MIT avec une maîtrise en Business Analytics. Pendant son temps libre, vous pouvez le trouver faire de l'escalade, de la randonnée ou continuer à développer ses compétences culinaires quelque peu rudimentaires.

Juin Li est data scientist au sein de l'équipe d'intelligence artificielle de Travelers's Business Insurance, où elle dirige et coordonne les travaux du portefeuille d'imagerie IA. Elle est passionnée par la mise en œuvre de solutions d'IA innovantes qui apportent une valeur substantielle aux partenaires commerciaux et aux parties prenantes. Son travail a joué un rôle essentiel dans la transformation de défis commerciaux complexes en opportunités en tirant parti des technologies d'IA de pointe.

Sourav Bhabesh est un scientifique appliqué senior chez AWS Titan Labs, où il développe les capacités et les fonctionnalités du modèle fondamental (FM). Sa spécialité est le traitement automatique du langage naturel (TAL) et il est passionné par l'apprentissage en profondeur. En dehors du travail, il aime lire et voyager.

Laura Kulowski est scientifique appliquée au Generative AI Innovation Center d'Amazon, où elle travaille en étroite collaboration avec les clients pour créer des solutions d'IA génératives. Pendant son temps libre, Laura aime explorer de nouveaux endroits à vélo.

André Ang est ingénieur senior en apprentissage machine chez AWS. En plus d'aider les clients à créer des solutions d'IA/ML, il aime les sports nautiques, le squash et regarder des vlogs sur les voyages et la nourriture.

Mehdi Nouri est responsable des sciences appliquées au Generative AI Innovation Center. Passionné par la technologie et l'innovation, il aide les clients d'AWS à libérer le potentiel de l'IA générative, en transformant les défis potentiels en opportunités d'expérimentation et d'innovation rapides en se concentrant sur des utilisations évolutives, mesurables et percutantes des technologies d'IA avancées et en rationalisant le chemin. à la fabrication.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Automobile / VE, Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• GraphiquePrime. Élevez votre jeu de trading avec ChartPrime. Accéder ici.
• Décalages de bloc. Modernisation de la propriété des compensations environnementales. Accéder ici.
• La source: https://aws.amazon.com/blogs/machine-learning/train-self-supervised-vision-transformers-on-overhead-imagery-with-amazon-sagemaker/