Vous pouvez exécuter des calculs matriciels lourds sur un seul GPU si vous chargez des données dans carrelage et conservez géoréférencement droit. Ce guide présente un modèle épuré à utiliser avec votre fournisseur de services GPU en utilisant rasterio pour les métadonnées et les E/S, CUCIM/CUPY pour la rapidité, et pyproj lorsque vous avez besoin d'une reprojection.
À vrai dire, tous les fichiers GeoTIFF ne se lisent pas de manière native sur le GPU. Le chemin fiable est Lecture du processeur → calcul du processeur graphique → écriture du processeur, effectué dans des fenêtres correspondant au tuilage interne du fichier. CuCim peut lire de nombreux TIFF en mosaïque directement sur le GPU ; quand ce n'est pas le cas, vous gagnez quand même en copiant les fenêtres dans CuPy avant le calcul.
1) Choisissez une image
Deux bonnes options :
A) Image RAPIDS (démarrage rapide)<24.xx>docker.io/rapidsai/rapidsai : -cuda12-runtime-ubuntu22.04-py3.10
B) Base CUDA + bibliothèques Python
Démarrez à partir d'un environnement d'exécution CUDA (par exemple, Ubuntu 24.04/CUDA 12.x), puis installez :
# micromamba (recommandé)
micromamba create -y -n geo -c conda-forge -c rapidsai \
python=3.10 rastério pyproj cuff cupy cucim
micromamba active geo
python -c « importer un rasterio, pyproj, cupy, cucim ; print ('ok') »
Votre modèle doit définir :
NVIDIA Visible_Devices = TousNVIDIA Driver_Capabilities=Calcul, utilitaire
Contrôle sanitaire à l'intérieur du conteneur :
nvidia-smi
2) Utilisez des GeoTiffs (COG) optimisés pour le cloud lorsque vous le pouvez
boutique COG carreaux intérieurs et vues d'ensemble qui rendent la lecture fenêtrée prévisible. Même pour les fichiers locaux, la disposition COG permet d'accélérer les E/S et fonctionne bien avec le tuilage du GPU. Si possible, convertissez une fois en COG avec 512 × 512 ou 1024 × 1024 tuiles et LZW/Deflate/ZStd.
Start in seconds with the fastest, most affordable cloud GPU clusters.
Launch an instance in under a minute. Enjoy flexible pricing, powerful hardware, and 24/7 support. Scale as you grow—no long-term commitment needed.
3) Schéma A : lecture du processeur → calcul du processeur graphique → écriture du processeur (valeur par défaut robuste)
Cela fonctionne sur n'importe quel GeoTIFF et conserve le géoréférencement intact.
Exemple : NDVI à partir des bandes RED/NIR
importer un rasterio
depuis la fenêtre d'importation rasterio.windows
importation de cupy en tant que tasse
importer numpy en tant que nl
src_path = "scene.tif" # GeoTIFF multibande (par exemple, bande 3 = ROUGE, bande 4 = NIR)
dst_path = « ndvi.tif »
BANDE_ROUGE, BANDE_NOIRE = 3, 4
avec rasterio.open (src_path) comme src :
profil = src.profile.copy ()
profile.update (count=1, dtype="float32", nodata=np.nan)
tile_w, tile_h = src.block_shapes [0] # utilise le carrelage interne
avec rasterio.open (dst_path, « w », **profile) comme dst :
pour ji, fenêtre dans src.block_windows (1) : # itérer les tuiles
rouge = src.read (RED_BAND, fenêtre=fenêtre) .astype (« float32")
nir = src.read (NIR_BAND, fenêtre=fenêtre) .astype (« float32")
# passer au GPU
red_d = cp.asarray (rouge)
nir_d = cp.asarray (nir)
# NDVI = (NIR - ROUGE)/(NIR + ROUGE)
denom = nir_d + red_d
ndvi_d = cp.where (denom ! = 0, (nir_d - red_d) /denom, cp.nan)
# retournez au processeur et écrivez
dst.write (cp.asnumpy (ndvi_d), 1, fenêtre=fenêtre)
Pourquoi cela fonctionne
- Poignées Rasterio CRS/Transform/NoData et écrit un GeoTIFF valide.
- Vous ne déplacez qu'un tuile à la fois sur le GPU, de sorte que la VRAM reste limitée.
- Fonctionne avec des entrées compressées ; la décompression se produit pendant
src.read ().
4) Modèle B — Lecture native du GPU avec CUCim (si pris en charge)
CUCim peut lire de nombreux TIFF en mosaïque directement sur le GPU sans matrice de processeurs intermédiaire. Vous utilisez toujours rasterio pour récupérer les métadonnées et écrire des sorties.
importer un rasterio
importation de cupy en tant que tasse
depuis cucim import CUImage
depuis la fenêtre d'importation rasterio.windows
src_path = « scene.tif »
bande_rouge, bande_noire = 3, 4
avec rasterio.open (src_path) comme src :
H, W = src.height, src.width
tile_w, tile_h = src.block_shapes [0]
cu = CUImage (src_path)
profile = src.profile.copy () ; profile.update (count=1, dtype="float32")
avec rasterio.open (» ndvi.tif «, « w », **profile) comme dst :
pour _, fenêtre dans src.block_windows (1) :
col_off, row_off = fenêtre.col_off, fenêtre.row_off
w, h = fenêtre.largeur, fenêtre.hauteur
# Lire une sous-région (x, y, w, h) directement sur le GPU
# Remarque : certains fichiers/pilotes peuvent nécessiter des solutions de secours ; gérez les exceptions.
région = cu.read_region (
emplacement= (col_off, row_off), taille= (w, h), niveau=0
) # renvoie un tableau avec bands-last
# découpez les bandes et passez à CuPy
nir_d = cp.asarray (région [..., nir_band - 1], dtype=cp.float32)
red_d = cp.asarray (région [..., bande_rouge - 1], dtype=cp.float32)
ndvi_d = (nir_d - red_d) /cp.where ((nir_d + red_d) ! = 0, (nir_d + red_d), cp.nan)
dst.write (cp.asnumpy (ndvi_d), 1, fenêtre=fenêtre)
Mises en garde
- L'ordre des bandes peut être bands‑last; ajustez l'indexation.
- Certaines fonctionnalités de GeoTIFF ne sont pas entièrement prises en charge par CUCIM ; interceptez les exceptions et revenez au modèle A.
5) Reprojection (restez simple)
Effectuez le calcul de distorsion une fois sur le processeur pour produire un grille cible, puis échantillonnez sur GPU.
importer numpy en tant que np, cupy en tant que cp, rasterio
depuis rasterio.warp import calculate_default_transform
depuis rasterio.vrt, importez WarpedVRT
src = rasterio.open (» scene.tif «)
dst_crs = « EPSG:32633" # exemple UTM
transformation, largeur, hauteur = calculate_default_transform (src.crs, dst_crs, src.width, src.height, *src.bounds)
# Créez une vue virtuelle déformée (rasterio gère la géodésie et le rééchantillonnage)
avec WarpedVrt (src, crs=dst_crs, transform=transform, width=width, height=height, Resampling=rasterio.enums.resampling.Bilinear) comme vrt :
profile = vrt.profile.copy () ; profile.update (dtype="float32", count=1)
avec rasterio.open (» band3_utm.tif «, « w », **profile) comme dst :
pour _, fenêtre dans vrt.block_windows (1) :
arr = vrt.read (3, fenêtre=fenêtre) .astype (« float32")
# faites des calculs GPU sur les tuiles déformées si nécessaire
arr_d = cp.asarray (arr)
#... calculez...
dst.write (cp.asnumpy (arr_d), 1, fenêtre=fenêtre)
Pourquoi cette approche
- Tu gardes géodésie (transformations CRS, rééchantillonnage des noyaux) dans une bibliothèque éprouvée.
- Vous obtenez toujours des accélérations du GPU pour les lourds mathématiques par pixel après distorsion.
6) Conseils sur les performances et la VRAM
- Correspond à la taille de bloc du fichier (
jeu de données.block_shapes) pour les fenêtres ; n'inventez pas de tailles étranges. - Préférez float32 pour les calculs, sauf si vous avez prouvé que FP64 est requis.
- Limiter les vignettes simultanées; traiter 1 à 4 à la fois en fonction de la VRAM.
- Évitez la surcharge de Python par tuile en regroupant les fenêtres et en utilisant des boucles simples.
- Écrivez des fichiers moins nombreux et plus volumineux (ou COG avec tuilage interne) pour réduire la surcharge des métadonnées.
7) Auto-évaluation et calcul des coûts
entrées : taille du fichier, bandes, dtype, tuiles, CRS
matériel : modèle GPU/VRAM, CUDA, pilote ; modèle de processeur
code : versions (rasterio, cucim, cupy)
paramètres : tuiles/sec, Mo/sec, temps mural, pic de VRAM
Coût par 100 Go traités
coût_par_100 Go = prix_par_heure × mur_heures × (100/(Go_traité))
8) Résolution des problèmes
CHAMBRE GPU
Traitez des tuiles plus ou moins nombreuses ; moulées en float32 ; tableaux libres (del arr_d ; cp._default_memory_pool.free_all_blocks ()).
Des résultats étranges
Bandes non concordantes ou aucune gestion des données. Vérifiez l'ordre des bandes ; ne propagez aucune donnée à la sortie.
Lectures lentes
Pas un COG, de minuscules carreaux ou une forte compression. Convertissez-le une fois en un COG bien structuré.
Erreurs CUCIM
Revenez au modèle A et enregistrez les informations de création du fichier pour une conversion ultérieure.
Extrait de méthodes (copier-coller)
matériel :
processeur graphique : « <model>(<VRAM>Go) »
chauffeur : « <NVIDIA driver>»
<CUDA version>cuda : « »
logiciel :
<24.xx>image : « rapidsai/rapidsai : -cuda12-runtime-ubuntu22.04-py3.10"
bibliothèques :
<ver>- rasterio : "»
<ver>- coucim : « »
<ver>- tasse : « »
<ver>- projet : « »
entrées :
fichier : « scene.tif (bands=<... >, dtype=<... >) »
<EPSG:...>grille : « CRS=, transform=< ... > »
courir :
schéma : « Lecture du processeur → calcul du processeur graphique → écriture du processeur (tuiles) »
tuile : « <w>× <h>from block_shapes »
sorties :
wall_seconds : « <... > »
tiles_per_sec : « <... > »
mb_per_sec : « <... > »
note : « COG ? compression ? rééchantillonnage ? aucune propagation de données »
Lecture associée
Essayez Compute dès aujourd'hui
Démarrez une instance GPU avec un modèle compatible CUDA (par exemple, Ubuntu 24.04 LTS/CUDA 12.6) ou votre propre image GROMACS. Profitez d'une facturation flexible à la seconde avec modèles personnalisés et la possibilité de démarrer, d'arrêter et de reprendre vos sessions à tout moment. Vous n'êtes pas sûr des exigences du FP64 ? Contactez le support pour vous aider à sélectionner le profil matériel le mieux adapté à vos besoins informatiques.
