Surveillance de la sécheresse dans le lac Mead à l'aide des nouvelles fonctionnalités géospatiales d'Amazon SageMaker

Le changement climatique de la Terre présente un risque accru de sécheresse en raison du réchauffement climatique. Depuis 1880, la température mondiale a augmenté de 1,01°C. Depuis 1993, le niveau de la mer a augmenté de 102,5 mm. Depuis 2002, la calotte glaciaire de l’Antarctique a perdu de la masse à un rythme de 151,0 milliards de tonnes métriques par an. En 2022, l’atmosphère terrestre contient plus de 400 parties par million (ppm) de dioxyde de carbone, soit 50 % de plus qu’en 1750. Bien que ces chiffres puissent sembler éloignés de notre vie quotidienne, la température de la Terre a augmenté à un niveau sans précédent. taux tout au long de l’année. les 10 000 dernières années (1).

Dans cet article, nous utilisons les nouvelles capacités géospatiales d’Amazon SageMaker pour surveiller les sécheresses causées par le changement climatique au lac Mead. Le lac Mead est le plus grand réservoir des États-Unis. Il alimente en eau 25 millions de personnes dans les États du Nevada, de l’Arizona et de la Californie (2). Les recherches montrent que les niveaux d’eau du lac Mead sont à leur plus bas depuis 1937 (3). Nous utilisons les capacités géospatiales de SageMaker pour mesurer les changements des niveaux d’eau dans le lac Mead à l’aide d’images satellites.

La saisie des données

Les nouvelles fonctionnalités géospatiales de SageMaker permettent d’accéder facilement aux données géospatiales telles que Sentinel-2 et Landsat 8. L’accès intégré aux ensembles de données géospatiales permet d’économiser des semaines d’efforts inutiles à collecter des données auprès de divers fournisseurs et fournisseurs de données.

Tout d’abord, nous allons utiliser un bloc-notes Amazon SageMaker Studio avec une image géospatiale SageMaker en suivant les étapes décrites dans Mise en route avec les capacités géospatiales d’Amazon SageMaker. Nous utilisons un bloc-notes SageMaker Studio avec une image géospatiale SageMaker pour notre analyse.

Le bloc-notes utilisé dans cet article se trouve dans le référentiel GitHub amazon-sagemaker-amples. SageMaker Geospatial facilite l’interrogation des données. Nous utiliserons le code suivant pour déterminer l’emplacement et la période des données satellitaires.

Dans l’extrait de code suivant, nous définissons d’abord un fichier AreaOfInterest (AOI) avec une boîte englobante autour de la région du lac Mead. Nous utilisons le TimeRangeFilter Pour sélectionner des données de janvier 2021 à juillet 2022. Cependant, les nuages ​​peuvent obscurcir la zone que nous étudions. Pour les images principalement sans nuages, nous sélectionnons un sous-ensemble d’images en fixant la limite supérieure de la couverture nuageuse à 1 %.

import boto3
import sagemaker
import sagemaker_geospatial_map

session = boto3.Session()
execution_role = sagemaker.get_execution_role()
sg_client = session.client(service_name="sagemaker-geospatial")

search_rdc_args = {
    "Arn": "arn:aws:sagemaker-geospatial:us-west-2:378778860802:raster-data-collection/public/nmqj48dcu3g7ayw8",  # sentinel-2 L2A COG
    "RasterDataCollectionQuery": {
        "AreaOfInterest": {
            "AreaOfInterestGeometry": {
                "PolygonGeometry": {
                    "Coordinates": (
                        (
                            (-114.529, 36.142),
                            (-114.373, 36.142),
                            (-114.373, 36.411),
                            (-114.529, 36.411),
                            (-114.529, 36.142),
                        ) 
                    )
                }
            } # data location
        },
        "TimeRangeFilter": {
            "StartTime": "2021-01-01T00:00:00Z",
            "EndTime": "2022-07-10T23:59:59Z",
        }, # timeframe
        "PropertyFilters": {
            "Properties": ({"Property": {"EoCloudCover": {"LowerBound": 0, "UpperBound": 1}}}),
            "LogicalOperator": "AND",
        },
        "BandFilter": ("visual"),
    },
}

tci_urls = ()
data_manifests = ()
while search_rdc_args.get("NextToken", True):
    search_result = sg_client.search_raster_data_collection(**search_rdc_args)
    if search_result.get("NextToken"):
        data_manifests.append(search_result)
    for item in search_result("Items"):
        tci_url = item("Assets")("visual")("Href")
        print(tci_url)
        tci_urls.append(tci_url)

    search_rdc_args("NextToken") = search_result.get("NextToken")

modèle d’inférence

Après avoir sélectionné les données, l’étape suivante consiste à extraire les masses d’eau de l’imagerie satellitaire. Habituellement, nous devons former un modèle de fragmentation de la couverture terrestre à partir de zéro pour identifier différentes classes de matériaux physiques à la surface de la Terre, tels que les masses d’eau, la végétation, la neige, etc. La formation d’un modèle à partir de zéro prend du temps et coûte cher. Inclut le balisage des données, la formation des modèles et le déploiement. Les capacités géospatiales de SageMaker fournissent un modèle de segmentation de la couverture terrestre pré-formé. Le modèle de segmentation de la couverture terrestre peut être exécuté avec un simple appel d’API.

Au lieu de télécharger les données sur une machine locale pour les inférences, SageMaker fait tout le gros du travail pour vous. Nous définissons simplement la configuration des données et la configuration du modèle dans la mission d’observation de la Terre (EOJ). SageMaker télécharge et prétraite automatiquement les données d’images satellites, les préparant pour l’inférence. Ensuite, SageMaker exécute automatiquement l’inférence du modèle EOJ. En fonction de la charge de travail (combien d’images sont exécutées via l’inférence de modèle), l’EOJ peut prendre plusieurs minutes à quelques heures pour se terminer. Vous pouvez surveiller l’état du travail avec un fichier get_earth_observation_job emploi.

# Perform land cover segmentation on images returned from the sentinel dataset.
eoj_input_config = {
    "RasterDataCollectionQuery": {
        "RasterDataCollectionArn": "arn:aws:sagemaker-geospatial:us-west-2:378778860802:raster-data-collection/public/nmqj48dcu3g7ayw8",
        "AreaOfInterest": {
            "AreaOfInterestGeometry": {
                "PolygonGeometry": {
                    "Coordinates": (
                        (
                            (-114.529, 36.142),
                            (-114.373, 36.142),
                            (-114.373, 36.411),
                            (-114.529, 36.411),
                            (-114.529, 36.142),
                        )
                    )
                }
            }
        },
        "TimeRangeFilter": {
            "StartTime": "2021-01-01T00:00:00Z",
            "EndTime": "2022-07-10T23:59:59Z",
        },
        "PropertyFilters": {
            "Properties": ({"Property": {"EoCloudCover": {"LowerBound": 0, "UpperBound": 1}}}),
            "LogicalOperator": "AND",
        },
    }
}
eoj_config = {"LandCoverSegmentationConfig": {}}

response = sg_client.start_earth_observation_job(
    Name="lake-mead-landcover",
    InputConfig=eoj_input_config,
    JobConfig=eoj_config,
    ExecutionRoleArn=execution_role,
)

# Monitor the EOJ status.
eoj_arn = response("Arn")
job_details = sg_client.get_earth_observation_job(Arn=eoj_arn)
{k: v for k, v in job_details.items() if k in ("Arn", "Status", "DurationInSeconds")}

Visualisez les résultats

Maintenant que nous avons exécuté l’inférence d’échantillon, examinons visuellement les résultats. Nous superposons les résultats d’inférence du modèle sur les images satellites d’entrée. Nous utilisons les outils Foursquare Studio pré-intégrés à SageMaker pour visualiser ces résultats. Tout d’abord, nous créons une instance de carte à l’aide des capacités géospatiales de SageMaker pour visualiser les images d’entrée et les prédictions du modèle :

# Creates an instance of the map to add EOJ input/ouput layer.
map = sagemaker_geospatial_map.create_map({"is_raster": True})
map.set_sagemaker_geospatial_client(sg_client)

# Render the map.
map.render()

Lorsque la carte interactive est prête, nous pouvons restituer les images d’entrée et de sortie du modèle sous forme de couches de carte sans avoir à télécharger les données. De plus, nous pouvons donner à chaque couche une étiquette et spécifier les données pour une date spécifique en utilisant TimeRangeFilter:

# Visualize AOI
config = {"label": "Lake Mead AOI"}
aoi_layer = map.visualize_eoj_aoi(Arn=eoj_arn, config=config)

# Visualize input.
time_range_filter = {
    "start_date": "2022-07-01T00:00:00Z",
    "end_date": "2022-07-10T23:59:59Z",
}
config = {"label": "Input"}
input_layer = map.visualize_eoj_input(
    Arn=eoj_arn, config=config, time_range_filter=time_range_filter
)

# Visualize output, EOJ needs to be in completed status.
time_range_filter = {
    "start_date": "2022-07-01T00:00:00Z",
    "end_date": "2022-07-10T23:59:59Z",
}
config = {"preset": "singleBand", "band_name": "mask"}
output_layer = map.visualize_eoj_output(
    Arn=eoj_arn, config=config, time_range_filter=time_range_filter
)

Nous pouvons vérifier que la zone marquée par l’eau (jaune clair dans la carte suivante) correspond précisément à la masse d’eau du lac Mead en modifiant l’opacité du calque résultant.

post-analyse

Ensuite, nous utilisons un fichier export_earth_observation_job Fonction permettant d’exporter les résultats EOJ vers un compartiment Amazon Simple Storage Service (Amazon S3). Nous effectuons ensuite une post-analyse des données dans Amazon S3 pour calculer la surface de l’eau. La fonctionnalité d’exportation facilite le partage des résultats entre les équipes. SageMaker simplifie également la gestion de la collecte de données. Nous pouvons simplement partager les résultats EOJ à l’aide de la fonction ARN, au lieu d’explorer des milliers de fichiers dans un compartiment S3. Chaque EOJ devient un atout dans le catalogue de données, où les résultats peuvent être regroupés par fonction ARN.

sagemaker_session = sagemaker.Session()
s3_bucket_name = sagemaker_session.default_bucket()  # Replace with your own bucket if needed
s3_bucket = session.resource("s3").Bucket(s3_bucket_name)
prefix = "eoj_lakemead"  # Replace with the S3 prefix desired
export_bucket_and_key = f"s3://{s3_bucket_name}/{prefix}/"

eoj_output_config = {"S3Data": {"S3Uri": export_bucket_and_key}}
export_response = sg_client.export_earth_observation_job(
    Arn=eoj_arn,
    ExecutionRoleArn=execution_role,
    OutputConfig=eoj_output_config,
    ExportSourceImages=False,
)

Ensuite, nous analysons les changements du niveau d’eau dans le lac Mead. Nous téléchargeons des masques de couverture terrestre sur notre copie locale pour calculer la surface de l’eau à l’aide de bibliothèques open source. SageMaker enregistre la sortie du modèle au format Cloud Optimized GeoTiff (COG). Dans cet exemple, nous chargeons ces masques sous forme de tableaux NumPy à l’aide du package Tifffile. faiseur sage Geospatial 1.0 Le noyau comprend également d’autres bibliothèques largement utilisées telles que GDAL et Rasterio.

Chaque pixel du masque de couverture du sol a une valeur comprise entre 0 et 11. Chaque valeur correspond à une classe spécifique d’occupation du sol. L’indice de classe d’eau est 6. Nous pouvons utiliser cet indice de classe pour extraire le masque d’eau. Tout d’abord, nous comptons le nombre de pixels marqués comme de l’eau. Ensuite, nous multiplions ce nombre par la surface couverte par chaque pixel pour obtenir la surface de l’eau. Selon les bandes, la résolution spatiale de l’image Sentinel-2 L2A est de 10M20Mou 60M. Toutes les échelles sont réduites à une résolution spatiale de 60 m pour l’inférence du modèle de fragmentation de la couverture terrestre. En conséquence, chaque pixel du masque d’occupation du sol représente une superficie terrestre de 3600 M²soit 0,0036 combien².

import os
from glob import glob
import cv2
import numpy as np
import tifffile
import matplotlib.pyplot as plt
from urllib.parse import urlparse
from botocore import UNSIGNED
from botocore.config import Config

# Download land cover masks
mask_dir = "./masks/lake_mead"
os.makedirs(mask_dir, exist_ok=True)
image_paths = ()
for s3_object in s3_bucket.objects.filter(Prefix=prefix).all():
    path, filename = os.path.split(s3_object.key)
    if "output" in path:
        mask_name = mask_dir + "/" + filename
        s3_bucket.download_file(s3_object.key, mask_name)
        print("Downloaded mask: " + mask_name)

# Download source images for visualization
for tci_url in tci_urls:
    url_parts = urlparse(tci_url)
    img_id = url_parts.path.split("/")(-2)
    tci_download_path = image_dir + "/" + img_id + "_TCI.tif"
    cogs_bucket = session.resource(
        "s3", config=Config(signature_version=UNSIGNED, region_name="us-west-2")
    ).Bucket(url_parts.hostname.split(".")(0))
    cogs_bucket.download_file(url_parts.path(1:), tci_download_path)
    print("Downloaded image: " + img_id)

print("Downloads complete.")

image_files = glob("images/lake_mead/*.tif")
mask_files = glob("masks/lake_mead/*.tif")
image_files.sort(key=lambda x: x.split("SQA_")(1))
mask_files.sort(key=lambda x: x.split("SQA_")(1))
overlay_dir = "./masks/lake_mead_overlay"
os.makedirs(overlay_dir, exist_ok=True)
lake_areas = ()
mask_dates = ()

for image_file, mask_file in zip(image_files, mask_files):
    image_id = image_file.split("/")(-1).split("_TCI")(0)
    mask_id = mask_file.split("/")(-1).split(".tif")(0)
    mask_date = mask_id.split("_")(2)
    mask_dates.append(mask_date)
    assert image_id == mask_id
    image = tifffile.imread(image_file)
    image_ds = cv2.resize(image, (1830, 1830), interpolation=cv2.INTER_LINEAR)
    mask = tifffile.imread(mask_file)
    water_mask = np.isin(mask, (6)).astype(np.uint8)  # water has a class index 6
    lake_mask = water_mask(1000:, :1100)
    lake_area = lake_mask.sum() * 60 * 60 / (1000 * 1000)  # calculate the surface area
    lake_areas.append(lake_area)
    contour, _ = cv2.findContours(water_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    combined = cv2.drawContours(image_ds, contour, -1, (255, 0, 0), 4)
    lake_crop = combined(1000:, :1100)
    cv2.putText(lake_crop, f"{mask_date}", (10,50), cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 0, 0), 3, cv2.LINE_AA)
    cv2.putText(lake_crop, f"{lake_area} (sq km)", (10,100), cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 0, 0), 3, cv2.LINE_AA)
    overlay_file = overlay_dir + '/' + mask_date + '.png'
    cv2.imwrite(overlay_file, cv2.cvtColor(lake_crop, cv2.COLOR_RGB2BGR))

# Plot water surface area vs. time.
plt.figure(figsize=(20,10))
plt.title('Lake Mead surface area for the 2021.02 - 2022.07 period.', fontsize=20)
plt.xticks(rotation=45)
plt.ylabel('Water surface area (sq km)', fontsize=14)
plt.plot(mask_dates, lake_areas, marker="o")
plt.grid('on')
plt.ylim(240, 320)
for i, v in enumerate(lake_areas):
    plt.text(i, v+2, "%d" %v, ha="center")
plt.show()

Nous traçons la surface de l’eau au fil du temps dans la figure suivante. La superficie de l’eau a visiblement diminué entre février 2021 et juillet 2022. En moins de deux ans, la superficie du lac Mead est passée de plus de 300 combien² à moins de 250 combien²changement relatif de 18 %.

import imageio.v2 as imageio
from IPython.display import HTML

frames = ()
filenames = glob('./masks/lake_mead_overlay/*.png')
filenames.sort()
for filename in filenames:
    frames.append(imageio.imread(filename))
imageio.mimsave('lake_mead.gif', frames, duration=1)
HTML('')

Nous pouvons également extraire les limites des lacs et les superposer aux images satellites pour mieux visualiser les changements de la côte du lac. Comme le montre l’animation suivante, le littoral nord et sud-est s’est rétréci au cours des deux dernières années. En certains mois, la superficie a diminué de plus de 20 % d’une année sur l’autre.

Conclusion

Nous avons vu l’impact du changement climatique sur le rétrécissement du littoral du lac Mead. SageMaker prend désormais en charge l’apprentissage automatique géospatial (ML), ce qui permet aux scientifiques des données et aux ingénieurs en apprentissage automatique de créer, former et déployer plus facilement des modèles à l’aide de données géospatiales. Dans cet article, nous expliquons comment acquérir des données, effectuer des analyses et visualiser les modifications à l’aide des services SageMaker Geospatial AI/ML. Vous pouvez trouver le code de cet article dans le référentiel GitHub amazon-sagemaker-amples. Consultez les capacités géospatiales d’Amazon SageMaker pour en savoir plus.

Les références

(1) https://climate.nasa.gov/

(2) https://www.nps.gov/lake/learn/nature/overview-of-lake-mead.htm

(3) https://earthobservatory.nasa.gov/images/150111/lake-mead-keeps-dropping

---

À propos des auteurs

Xiong Chu Il est scientifique d’application senior chez AWS. Dirige l’équipe scientifique pour les capacités géospatiales d’Amazon SageMaker. Son domaine de recherche actuel comprend la vision par ordinateur et la formation de modèles actifs. Dans ses temps libres, il aime courir, jouer au basket et passer du temps avec sa famille.

Anirudh Viswanathan Il est chef de produit senior, technique – services d’externalisation au sein de l’équipe SageMaker geospatial ML. Il est titulaire d’une maîtrise en robotique de l’Université Carnegie Mellon, d’un MBA de la Wharton School of Business et est l’inventeur de plus de 40 brevets. Il aime courir sur de longues distances, visiter des galeries d’art et des spectacles à Broadway.

Peigne à lèvres de Trenton Il est architecte principal et fait partie de l’équipe qui a ajouté des capacités géospatiales à SageMaker. Il a été impliqué dans des solutions humaines en boucle, travaillant sur les services SageMaker Ground Truth, Augmented AI et Amazon Mechanical Turk.

Xingjian Shi Il est un scientifique d’application senior et fait partie de l’équipe qui a ajouté des capacités géospatiales à SageMaker. Il travaille également sur l’apprentissage profond pour les géosciences et l’AutoML multimédia.

Lee Iran Lee Il est directeur des sciences appliquées aux services humains chez Loop, AWS AI, Amazon. Ses intérêts de recherche sont l’apprentissage profond 3D, l’apprentissage de la vision et la représentation du langage. Il était auparavant scientifique principal chez Alexa AI, responsable de l’apprentissage automatique chez Scale AI et scientifique en chef chez Pony.ai. Auparavant, il faisait partie de l’équipe Cognition d’Uber ATG et de l’équipe Machine Learning Platform d’Uber, travaillant sur l’apprentissage automatique pour la conduite autonome, les systèmes d’apprentissage automatique et les initiatives stratégiques d’IA. Il a commencé sa carrière chez Bell Labs et a été professeur auxiliaire à l’Université de Columbia. Co-enseignant à ICML’17 et ICCV’19, et co-animateur de plusieurs ateliers NeurIPS, ICML, CVPR et ICCV sur l’apprentissage automatique pour la conduite autonome, la vision 3D, la robotique, les systèmes d’apprentissage automatique et l’apprentissage automatique contradictoire. Il est titulaire d’un doctorat en informatique de l’Université Cornell. Il est membre ACM et membre IEEE.