Cartographier les émissions mondiales de méthane depuis l'espace avec l'apprentissage profond

Cartographier les émissions mondiales de méthane depuis l’espace grâce à l’apprentissage profond

Le méthane est un défi invisible. Il s’échappe des puits, des pipelines, des décharges et des sites agricoles sans panache d’avertissement que nos yeux peuvent saisir sur des images conventionnelles. Depuis l’orbite, cependant, l’image est différente : les satellites peuvent enregistrer les signatures spectrales du méthane lorsqu’il absorbe la lumière du soleil et réémet de l’énergie infrarouge. L’écart entre l’image brute et une estimation précise des émissions relève de la science de la mesure. L’écart entre des millions d’images et une carte mondiale relève de l’automatisation. L’apprentissage profond est devenu le pont essentiel entre les deux.

Cet article parcourt les ingrédients techniques d’un système de cartographie du méthane reposant sur des données satellitaires et des réseaux de neurones. Il reflète l’approche conceptuelle décrite par Google Research dans son article d’ingénierie Mapping global methane emissions from space with deep learning, puis traduit ce concept en un flux de travail pratique et exécutable. Nous examinerons pourquoi le problème est difficile, ce que l’apprentissage profond apporte, et comment vous pouvez mettre en place votre propre chaîne d’inférence avec des outils librement disponibles. Tous les exemples d’installation et d’utilisation sont délibérément génériques : ils vous donnent un squelette fonctionnel plutôt que de prétendre reproduire le système propriétaire d’une organisation.

Le problème atmosphérique

Le dioxyde de carbone reçoit la plus grande partie de l’attention dans les discussions sur le climat, mais le méthane est un levier à court terme plus difficile. C’est un gaz à effet de serre puissant avec une durée de vie atmosphérique relativement courte, et ses sources sont dispersées. Certaines émissions sont importantes et continues. D’autres sont des événements de ventilation de courte durée qui ne durent que quelques minutes. Un système de surveillance doit donc combiner deux attributs qui coexistent rarement en télédétection : une couverture spatiale étendue et une fréquence de revisite élevée.

Les satellites n’observent pas le méthane directement. Ils observent la radiance dans des bandes spectrales étroites, et la présence de méthane modifie cette radiance de manières qui peuvent être converties en une augmentation de concentration au-dessus du fond local. Le signal brut est faible, et il peut facilement être corrompu par les bords des nuages, les surfaces minérales, le bruit thermique et la géométrie de visée variable des passages individuels. Lorsque les observations sont moyennées sur une grande région, une fuite peut devenir invisible. Lorsqu’elles sont examinées à pleine résolution, le rapport signal sur bruit devient un obstacle sérieux.

C’est précisément dans ce régime qu’un réseau de neurones bien entraîné surpasse le seuillage classique. Au lieu de demander si un pixel unique dépasse une valeur fixe, le modèle peut apprendre le contexte spatial d’un panache : le noyau brillant, la traîne diffuse, l’orientation sous le vent et le terrain environnant qui doit être traité comme fond. La sortie n’est plus un indicateur binaire mais une carte structurée des emplacements probables de panaches.

Là où l’apprentissage profond change l’approche

La chaîne de traitement satellitaire conventionnelle pour la cartographie des gaz traces passe par des rapports de bandes, des calculs de profondeur d’absorption et des seuils réglés par des experts. Ces méthodes sont compréhensibles et reproductibles, mais elles peinent face à l’énorme diversité des scènes. Un désert nu, une rizière inondée saisonnièrement, un lac gelé et un toit de ville produisent tous des fonds très différents. Un seuil fixe calibré sur un type de scène échoue souvent sur un autre.

L’apprentissage profond introduit plusieurs avantages pratiques :

• Raisonnement contextuel. Un réseau de neurones convolutif voit une patch de pixels, pas un pixel unique. Il peut utiliser le gradient lisse attendu dans un panache de gaz pour rejeter le bruit de type speckle.
• Représentations transférables. Un modèle entraîné sur un capteur peut être affiné sur un autre avec une fraction du jeu de données original, ce qui importe à mesure que de nouvelles missions d’observation du méthane entrent en service.
• Calibration de bout en bout. Au lieu de séparer la correction atmosphérique de l’étape de détection, le modèle peut être entraîné à produire directement des sorties liées aux émissions à partir de la réflectance au sommet de l’atmosphère, à condition que les étiquettes d’entraînement soient fiables.
• Analyse mondiale uniforme. Un modèle applique la même frontière de décision partout, ce qui rend possible le balayage de téraoctets d’imagerie et la remontée des seuls événements les plus intéressants pour les analystes humains.

Aucune de ces propriétés ne supprime la nécessité d’un prétraitement soigné ou d’une validation indépendante. Mais elles changent l’économie de l’analyse. Un analyste humain peut inspecter quelques milliers de scènes ; un modèle automatisé peut en filtrer des millions et orienter quelques centaines de cas ambigus vers une file d’examen.

Aucune de ces propriétés ne supprime la nécessité d’un prétraitement soigné ou d’une validation indépendante. Mais elles changent l’économie de l’analyse. Un analyste humain peut inspecter quelques milliers de scènes ; un modèle automatisé peut en filtrer des millions et orienter quelques centaines de cas ambigus vers une file d’examen.

Contexte vérifié pour cet article

Le fondement technique de cette discussion provient d’une source primaire unique et accessible : le billet de blog Google Research intitulé Mapping global methane emissions from space with deep learning (https://research.google/blog/mapping-global-methane-emissions-from-space-with-deep-learning), vérifié le 2026-09-01. Comme le titre l’indique, ce billet est un récit de blog de recherche plutôt qu’un article scientifique formel. Là où le présent article va au-delà du message général du blog, il le fait en des termes explicitement pratiques : les étapes d’installation, les routines de préparation des données et les extraits de code ci-dessous sont des exemples pédagogiques qui suivent la même trame générale, et non des représentations de l’implémentation de recherche originale.

Un flux de travail pratique de cartographie

Un système complet de cartographie du méthane contient plusieurs composants distincts qu’il est utile de garder séparés dans votre propre projet :

1. Acquisition des données. Les scènes satellitaires arrivent sous forme de GeoTIFF multi-bandes ou d’archives optimisées pour le cloud, souvent avec des fichiers de métadonnées séparés décrivant les conditions atmosphériques et la géométrie solaire.
2. Prétraitement. Les bandes doivent être rééchantillonnées à une résolution commune, les nuages doivent être masqués, et les valeurs de radiance doivent être converties en un produit de réflectance de surface comparable.
3. Détection. Un modèle de segmentation consomme des patches d’image et produit une probabilité par pixel de présence de méthane.
4. Agrégation au niveau de la scène. Les détections sont regroupées en panaches, et chaque panache est converti en une estimation d’ampleur et une étiquette de localisation.
5. Rapport et examen. Les résultats sont écrits dans des fichiers GeoPackage, CSV ou une carte interactive pour les analystes.

La suite de cet article se concentre sur les composants 1 à 4 avec une configuration réelle et épurée.

Prérequis

Vous aurez besoin de ce qui suit :

• Une machine Linux ou macOS. Windows fonctionne avec des modifications mineures de la commande d’activation.
• Python 3.10 ou plus récent. Nous créerons un environnement virtuel isolé.
• Au moins 12 Go d’espace disque pour les scènes de test. Une analyse à l’échelle de la production nécessite beaucoup plus.
• Un GPU NVIDIA avec au moins 8 Go de VRAM est fortement recommandé. Le script d’inférence d’exemple fonctionnera sur CPU, mais lentement.

Les packages Python que nous utiliserons sont standard dans l’écosystème de l’apprentissage automatique géospatial : rasterio pour lire les images satellitaires, numpy pour le calcul matriciel, torch et torchvision pour le modèle, et geopandas pour écrire les sorties vectorielles.

Installation étape par étape

Commencez par créer un environnement virtuel pour isoler les dépendances du reste de votre système.

python3 -m venv ~/.venvs/methane-ml

Activez l’environnement. Chaque commande ultérieure de cette section suppose que vous avez exécuté cette ligne d’activation dans le même terminal.

source ~/.venvs/methane-ml/bin/activate

Mettez à niveau les outils d’empaquetage de base avant d’installer quoi que ce soit d’autre.

pip install --upgrade pip setuptools wheel

Installez les bibliothèques numériques fondamentales et de gestion des données.

pip install numpy pandas matplotlib requests pyyaml tqdm

Installez PyTorch avec le support CUDA. Si vous n’avez pas de GPU NVIDIA, remplacez l’URL de l’index par la variante CPU uniquement suggérée sur le site officiel de PyTorch.

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121

Installez les bibliothèques de lecture géospatiale et de sortie vectorielle.

pip install rasterio shapely geopandas

Enfin, vérifiez que les importations critiques fonctionnent. Vous ne devriez voir aucun message d’erreur après les importations, et la ligne de disponibilité CUDA affichera False sur une machine CPU uniquement.

python -c "import torch, rasterio; print(torch.__version__); print(torch.cuda.is_available())"

Préparation d’une scène satellitaire

Les produits satellitaires arrivent dans de nombreux dialectes, mais le dénominateur commun est un raster multi-bandes. L’extrait ci-dessous suppose que vous avez déjà téléchargé une région d’intérêt et enregistré les fichiers GeoTIFF pertinents dans un dossier. Il empile les bandes spectrales sensibles à l’absorption du méthane, élimine les valeurs de bord invalides, et rééchantillonne toutes les bandes à la résolution la plus grossière afin qu’elles se trouvent sur une grille commune.

import rasterio
import numpy as np
from pathlib import Path

BANDS = ["B11", "B12", "B8A"]  # bandes infrarouges à ondes courtes autour de l'absorption du méthane

def prepare_scene(scene_dir: Path):
    arrays, meta = [], None
    for name in BANDS:
        path = scene_dir / f"{name}.tif"
        with rasterio.open(path) as src:
            if meta is None:
                meta = src.meta.copy()
                meta.update(count=len(BANDS), dtype="float32")
            arrays.append(src.read(1).astype("float32"))

    stack = np.stack(arrays, axis=0)
    cloud_path = scene_dir / "cloud_mask.tif"
    if cloud_path.exists():
        with rasterio.open(cloud_path) as src:
            cloud = src.read(1).astype("bool")
        stack[:, cloud] = np.nan  # masque les nuages avant que le modèle ne les voie

    with rasterio.open(scene_dir / "prepared.tif", "w", **meta) as dst:
        dst.write(stack)

    return scene_dir / "prepared.tif"

Notez que le choix de B11, B12 et B8A correspond aux canaux infrarouges à ondes courtes de Sentinel-2, qui sont couramment utilisés pour le dépistage des panaches. Si vos données sources utilisent une convention spectrale différente, vous devez mettre à jour la liste en conséquence. Le moyen le plus fiable de confirmer les bandes utilisables est d’inspecter les métadonnées de la scène et de comparer les descriptions de longueur d’onde avec les caractéristiques d’absorption du méthane.

Un modèle de segmentation minimal

Plutôt que d’écrire un grand U-Net à partir de zéro, l’exemple ci-dessous utilise un backbone convolutif compact qui accepte une patch multi-bandes et renvoie une carte de probabilité à canal unique. Il est volontairement assez petit pour être entraîné ou affiné sur un seul GPU, mais ce n’est pas le type d’architecture de qualité production décrit dans la littérature de recherche. Considérez-le comme une référence que vous pourrez remplacer plus tard.

import torch
import torch.nn as nn

class PlumeSegNet(nn.Module):
    def __init__(self, in_channels: int):
        super().__init__()
        self.encoder = nn.Sequential(
            nn.Conv2d(in_channels, 16, 3, padding=1), nn.ReLU(),
            nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(),
            nn.Conv2d(64, 64, 3, padding=1), nn.ReLU(),
        )
        self.decoder = nn.Sequential(
            nn.Upsample(scale_factor=2, mode="bilinear", align_corners=False),
            nn.Conv2d(64, 32, 3, padding=1), nn.ReLU(),
            nn.Conv2d(32, 1, 1),
            nn.Sigmoid(),
        )

    def forward(self, x):
        return self.decoder(self.encoder(x))

Ce modèle produit des valeurs entre 0 et 1 pour chaque pixel. Pendant l’entraînement, ces valeurs sont comparées à un masque binaire préparé par un analyste expert ou par une procédure d’étiquetage automatique. Pour la chaîne pédagogique, vous pouvez stocker le point de contrôle après l’entraînement et le réutiliser pour l’inférence sur de nouvelles scènes.

Exemples d’utilisation

Une fois l’environnement prêt, le modèle défini et un point de contrôle existant, l’inférence fonctionne en quatre étapes. D’abord, chargez le point de contrôle et placez le modèle en mode évaluation.

import torch

model = PlumeSegNet(in_channels=3)
checkpoint = torch.load("plume_checkpoint.pt", map_location="cpu")
model.load_state_dict(checkpoint["model_state_dict"])
model.eval()

Ensuite, lisez la scène préparée en patches. L’inférence par patch empêche les défaillances de mémoire insuffisante sur de très grands rasters.

import numpy as np
import rasterio
from rasterio.windows import Window

def predict_scene(prepared_path: str, patch_size: int = 256):
    with rasterio.open(prepared_path) as src:
        n_cols, n_rows = src.width, src.height
        result = np.zeros((n_rows, n_cols), dtype="float32")
        for row in range(0, n_rows, patch_size):
            for col in range(0, n_cols, patch_size):
                w = src.read(window=Window(col, row,
                                           min(patch_size, n_cols - col),
                                           min(patch_size, n_rows - row)))
                x = torch.from_numpy(w).unsqueeze(0)
                with torch.no_grad():
                    prob = model(x).squeeze(0).squeeze(0).numpy()
                h, ww = prob.shape
                result[row:row+h, col:col+ww] = prob
    return result

Troisièmement, extrayez les panaches de la carte de probabilité en tant que régions connectées au-dessus d’un seuil choisi. Le seuil doit être réglé sur des données de validation ; 0,5 n’est qu’un point de départ.

from scipy import ndimage

def extract_plumes(prob_map: np.ndarray, threshold: float = 0.5):
    binary = prob_map > threshold
    labeled, n_plumes = ndimage.label(binary)
    plumes = []
    for label_id in range(1, n_plumes + 1):
        ys, xs = np.where(labeled == label_id)
        plumes.append({
            "label": int(label_id),
            "pixels": int(len(xs)),
            "max_prob": float(prob_map[ys, xs].max()),
            "row_center": float(ys.mean()),
            "col_center": float(xs.mean()),
        })
    return plumes

Quatrièmement, écrivez les panaches et la carte de probabilité sur le disque afin qu’un analyste en aval puisse examiner les détections dans un outil SIG.

import json

with open("plumes.json", "w") as f:
    json.dump(plumes, f, indent=2)

with rasterio.open("prepared.tif") as src:
    profile = src.profile.copy()
    profile.update(dtype="float32", count=1, compress="deflate")
    with rasterio.open("probability.tif", "w", **profile) as dst:
        dst.write(prob_map, 1)

La ligne de commande complète pour une nouvelle scène ressemblerait alors à ceci :

python prepare_scene.py data/scene_2025_08_14
python predict_scene.py data/scene_2025_08_14 --checkpoint plume_checkpoint.pt
python export_plumes.py data/scene_2025_08_14 --threshold 0.5

Ce modèle en trois étapes a une valeur pratique au-delà du méthane. En gardant la préparation de la scène indépendante du modèle et en n’exposant qu’une entrée et une sortie géoréférencées, vous pouvez plus tard remplacer le backbone d’apprentissage profond par un plus puissant ou un ensemble de bandes spectrales complètement différent sans réécrire tout le système.

Limites et interprétation responsable

Un modèle qui détecte des motifs ressemblant à des panaches n’est pas encore un inventaire des émissions. La conversion des cartes de probabilité en tonnes par heure nécessite des estimations de la vitesse du vent, de la direction du vent, du transport atmosphérique et de la distribution verticale du gaz — des informations qu’un seul passage satellitaire peut ne pas fournir. Les chercheurs combinent fréquemment l’étape de détection des panaches avec un modèle de transport ou avec des observations simultanées d’un second instrument.

Il existe également des sources d’erreur qu’aucune quantité d’apprentissage profond ne peut éliminer. Les nuages et la réflexion du soleil suppriment des données. Les montagnes projettent des ombres qui imitent des gradients. Les infrastructures urbaines peuvent produire une confusion spectrale. Lorsqu’un modèle est entraîné sur un capteur, ses performances sur un autre doivent être réévaluées, surtout si la résolution spatiale diffère d’un ordre de grandeur.

L’état d’esprit correct pour le déploiement est le modèle humain-dans-la-boucle : l’apprentissage automatique trouve les événements candidats, les trie par confiance et maintient une règle de dépistage mondiale cohérente ; les analystes vérifient la liste restreinte, inspectent l’imagerie originale et décident quels événements justifient un suivi au sol. Cet arrangement utilise le réseau de neurones là où il est le plus fort — une recherche exhaustive et reproductible — et garde le jugement humain là où il est requis — l’attribution finale et la réponse politique.

Pour le praticien, les problèmes ouverts ne sont donc pas uniquement architecturaux. Il n’existe toujours pas de référentiel public universel qui mesure les performances de détection des panaches sur différents capteurs et types de terrain. Créer un tel référentiel, avec une vérité terrain soigneusement organisée, ferait probablement plus pour le domaine que n’importe quelle amélioration de modèle unique.

Conclusion

Cartographier le méthane depuis l’espace est un problème de mesure enveloppé dans un problème d’échelle. Une image satellitaire contient suffisamment de preuves pour localiser un panache, mais la quantité de données dépasse la capacité de l’analyse manuelle. L’apprentissage profond comble cet écart en apprenant la forme spectrale et spatiale des panaches, puis en appliquant cette connaissance de manière cohérente à chaque scène de la planète.

Cet article a parcouru la logique derrière cette approche, ancrée dans le billet de Google Research sur le sujet, et a fourni un chemin de code petit mais fonctionnel que vous pouvez exécuter aujourd’hui : un environnement Python avec rasterio et torch, une routine de préparation de scène multi-bandes, un modèle de segmentation et un script d’extraction de panaches. Les pièces sont délibérément modulaires, car le système réel qui produira éventuellement une carte mondiale de confiance du méthane ne sera pas un modèle unique et ingénieux. Ce sera une chaîne de traitement soignée des données, une validation honnête et un apprentissage automatique utilisé exactement là où il ajoute de la valeur — à la frontière de l’échelle.

Source primaire : Mapping global methane emissions from space with deep learning, blog Google Research, https://research.google/blog/mapping-global-methane-emissions-from-space-with-deep-learning (vérifié le 2026-09-01).