Web Analytics

tessera

⭐ 491 stars French by ucam-eo

Embeddings Temporels des Spectres de Surface pour la Représentation et l'Analyse de la Terre (TESSERA) [CVPR2026]

Bannière

Signaler des Bugs 🛠️   •   Demander des Fonctionnalités 💡

Version PyPI Licence

Table des Matières

En apprendre plus sur TESSERA

Introduction

La télédétection par satellite permet une large gamme d'applications en aval, notamment la cartographie des habitats, le comptage du carbone, et les stratégies de conservation et d'utilisation durable des terres. Cependant, les séries temporelles satellitaires sont volumineuses et souvent corrompues par les nuages, ce qui les rend difficiles à exploiter : la capacité de la communauté scientifique à extraire des informations exploitables est souvent limitée par la rareté des ensembles de données d'entraînement étiquetés et la charge computationnelle liée au traitement des données temporelles. L'idée clé de notre travail, due à Dr. Clement Atzberger, est que forcer l'alignement des embeddings d'auto-encodeurs dérivés de deux échantillons aléatoires sans nuages de séries temporelles satellitaires en utilisant Barlow Twins aboutit à un embedding représentant l'ensemble de la série temporelle, y compris les observations manquantes.

Cette idée est au cœur de TESSERA, un modèle fondation ouvert qui préserve les signaux spectral-temporels par pixel dans des représentations latentes de 128 dimensions à une résolution de 10 mètres à l'échelle mondiale. Il utilise l'apprentissage auto-supervisé pour résumer des pétaoctets de données d'observation de la Terre. Nous comparons notre travail avec des modèles spécifiques à la tâche à la pointe et d'autres modèles fondation dans cinq tâches en aval diverses et constatons que TESSERA égalise ou dépasse ces références. En préservant les signaux phénologiques temporels habituellement perdus dans les approches conventionnelles, TESSERA permet de nouvelles perspectives sur la dynamique des écosystèmes, les systèmes alimentaires agricoles et la détection des changements environnementaux. De plus, notre implémentation open-source soutient la reproductibilité et l'extensibilité, tandis que le design préservant la vie privée permet aux chercheurs de maintenir la souveraineté des données.

À notre connaissance, TESSERA est sans précédent par sa facilité d'utilisation, son échelle et sa précision : aucun autre modèle fondation ne fournit des sorties prêtes à l'analyse, est ouvert, et offre une couverture globale annuelle à 10 m de résolution en utilisant uniquement des caractéristiques spectral-temporelles au niveau pixel.

Voici quelques résultats de visualisation de la carte de représentation TESSERA (en utilisant les trois premiers canaux comme RGB) :

repr_demo

Articles

Voici les publications et prépublications liées à TESSERA, listées chronologiquement :

Présentations

Licence

Le logiciel TESSERA est publié sous la licence MIT standard. Les embeddings et les poids des modèles sont publiés sous la licence CC0 : essentiellement, ils peuvent être utilisés librement à des fins commerciales et non commerciales. Bien que nous n'exigions pas légalement d'attribution, nous la demandons toutefois.

Utilisation de TESSERA

Accès aux Embeddings via GeoTessera (recommandé)

Nous avons généré des embeddings pour le globe entier à une résolution de 10m pour 2024. Ils peuvent être téléchargés et utilisés pour des applications en aval, économisant un temps et des ressources computationnelles importants, en utilisant la bibliothèque GeoTessera. Nous étendrons progressivement la couverture vers les années précédentes jusqu’en 2017. La carte de couverture actuelle est ci-dessous :

Groupe d’Utilisateurs TESSERA

Les utilisateurs intéressés sont invités à rejoindre nos groupes de discussion Zulip.

Création de Vos Propres Embeddings

Si vous souhaitez utiliser notre logiciel pour créer vos propres embeddings, veuillez suivre les instructions ci-dessous. Notez qu’il s’agit d’une tâche computationnellement exigeante et que vous aurez besoin d’un accès à des ressources computationnelles et de stockage significatives.

Exigences Matérielles

1. Exigences de Stockage

L’exécution de ce pipeline nécessite un espace de stockage important. Bien que le pipeline supprime certains fichiers intermédiaires après traitement, les fichiers bruts Sentinel-2 et Sentinel-1 téléchargés occuperont néanmoins un espace disque considérable. Par exemple, traiter une zone de 100km×100km de 2022 pour produire une carte de représentation TESSERA (résolution 10m) nécessite au moins 1 To de stockage.

2. Exigences en Mémoire

Nous utilisons des données prétraitées, initialement issues de Microsoft Planetary Computer. Cependant, la prochaine génération d’embeddings utilisera OPERA de ASF DAAC. Dans les deux cas, la majorité du prétraitement géospatial a déjà été effectué. Nous recommandons néanmoins d’avoir au moins 128 Go de RAM.

3. CPU et GPU

Le pipeline n’a pas d’exigences strictes en CPU et GPU, mais plus de cœurs CPU et des GPU plus puissants peuvent considérablement accélérer l’inférence. Lors du traitement d’une zone de 110km×110km en 2022, nos tests utilisant un CPU 128 cœurs et un seul GPU NVIDIA A30 pour l’inférence (CPU et GPU traitant chacun 50 % de l’inférence) ont pris environ 10 heures pour se terminer.

4. Système d'exploitation

Pour le pipeline de prétraitement des données, nous supportons presque tous les systèmes Linux. Pour Windows, nous recommandons d'utiliser WSL. Nous ne supportons pas MacOS pour le moment.

Pour la partie inférence du modèle, nous l'avons seulement testée sous Linux et Windows WSL, et cela fonctionne.

Prétraitement des données

Vue d'ensemble

_Nous recommandons vivement de parcourir rapidement l'ensemble du tutoriel avant d'exécuter le pipeline._

À cette étape, nous empilons une année complète de données Sentinel-1 et Sentinel-2 selon la dimension temporelle pour générer un composite. Pour Sentinel-2, la forme du composite est (T,H,W,B), où T est le nombre d'observations valides dans l'année, et B est le nombre de bandes (nous avons sélectionné 10 bandes). Pour Sentinel-1, nous avons extrait les données des orbites ascendantes et descendantes. En prenant l'orbite ascendante comme exemple, la forme du composite est (T',H,W,B'), où T' est le nombre d'observations ascendantes valides dans l'année, et B' est 2 car nous n'obtenons que les bandes VV et VH.

Nous avons initialement obtenu les données Sentinel-1 et Sentinel-2 depuis le Planetary Computer de Microsoft :

La nouvelle génération d'embeddings utilisera OPERA de ASF DAAC : Actuellement, notre pipeline n'accepte que des entrées au format TIFF. La résolution du TIFF de la zone d'intérêt (ROI) peut varier (par exemple, 30m), mais le pipeline générera toujours des sorties Sentinel-1 et Sentinel-2 à la RESOLUTION configurée (par défaut 10m) tout en conservant l'étendue/les limites de la ROI identiques. Pour les zones valides de la ROI dans le TIFF, la valeur est 1 ; sinon, c'est 0. Si vous avez seulement un shapefile, cela convient aussi - nous fournissons un script convert_shp_to_tiff.py.

Télécharger le code source

Commencez par créer un répertoire de travail vide :

mkdir tessera_project
cd tessera_project
git clone https://github.com/ucam-eo/tessera.git
Pour faciliter l'exploitation du pipeline, nous recommandons de placer le répertoire de sortie des données au même niveau que tessera_infer et tessera_preprocessing :

tessera_project
 ┣ tessera_infer
 ┣ tessera_preprocessing
 ┣ my_data
   ┣ roi.shp (your shapefile)
   ┗ roi.tiff (we recommend generating this using convert_shp_to_tiff.py)

Le fichier roi.tiff peut être généré en utilisant convert_shp_to_tiff.py situé dans tessera_preprocessing/convert_shp_to_tiff.py. Pour l’utiliser, spécifiez simplement le chemin vers votre fichier shapefile dans la fonction principale, et il produira un TIFF portant le même nom dans le même répertoire.

⚠️Avis : _Si votre ROI est relativement grand, par exemple 100 km × 100 km, nous recommandons fortement de pré-découper le TIFF en sections plus petites ne dépassant pas 20 km × 20 km. Traitez ensuite chaque petit fichier TIFF séquentiellement dans la chaîne de traitement. Un ROI excessivement grand peut provoquer des problèmes avec les fournisseurs de tuiles en backend_

Environnement Python

Nous avons besoin de certains paquets de traitement géographique (heureusement, nous n’utiliserons pas GDAL, car configurer cet environnement est un cauchemar) et de quelques paquets d’apprentissage automatique (PyTorch, mais vous devrez l’installer vous-même car le matériel varie selon les ordinateurs). Nous avons mis quelques paquets courants dans requirements.txt, que vous pouvez installer comme suit :

pip install -r requirements.txt
Remarque : Si vous êtes dans un environnement géré, vous devrez peut-être d'abord installer un venv, en utilisant 
python3 -m venv venv
source venv/bin/activate

Configuration du script

Tout d’abord, naviguez vers le dossier tessera_preprocessing :

cd tessera_preprocessing

Puis modifiez le fichier s1_s2_downloader.sh pour indiquer le fichier TIFF de la ZOI, les répertoires de sortie et temporaires, ainsi que la source des données :

# === Basic Configuration ===
INPUT_TIFF="/absolute/path/to/your/data_dir/roi.tiff"
OUT_DIR="/absolute/path/to/your/data_dir"
export TEMP_DIR="/absolute/path/to/your/temp_dir"     # Temporary file directory
mkdir -p "$OUT_DIR"
Python environment path

PYTHON_ENV="/absolute/path/to/your/python_env/bin/python"
=== Sentinel-1 & Sentinel-2 Processing Configuration ===

YEAR=2022 # Range [2017-2025]
RESOLUTION=10.0  # Output resolution (meters). ROI TIFF can be any resolution; extent is preserved.
=== Data Source Configuration ===


mpc: Microsoft Planetary Computer (sentinel-1-rtc, sentinel-2-l2a)


aws: AWS Open Data backends (S1=OPERA RTC-S1 via ASF/CMR + ASF Earthdata Cloud COGs, S2=Earth-search Sentinel-2 L2A COGs)

DATA_SOURCE="mpc"   # choices: mpc/aws

Note : RESOLUTION contrôle la taille des pixels de sortie. Le pipeline maintient les limites du ROI fixes et rééchantillonne le masque ROI dans la grille de sortie.

Identifiants AWS (nécessaires uniquement lorsque DATA_SOURCE="aws")

Sentinel-2 sur Earth-search est public et ne nécessite pas d’identifiants.

Sentinel-1 OPERA RTC-S1 est accessible via ASF Earthdata Cloud (COG via HTTPS). Vous avez besoin d’un jeton Earthdata Login :

Recommandé (simple + explicite) :

nano ~/.edl_bearer_token

paste token, save+exit (Ctrl-O Enter, then Ctrl-X)

chmod 600 ~/.edl_bearer_token

Le téléchargeur AWS S1 utilisera ce jeton pour lire les COGs depuis ASF Earthdata Cloud.

Si vous souhaitez récupérer des identifiants S3 temporaires (avancé ; généralement non requis pour ce pipeline), consultez les instructions ASF :

En dessous de la configuration ci-dessus, il y a des configurations supplémentaires que vous pouvez modifier en fonction des performances de votre ordinateur.

Tout d'abord, donnez la permission à s1_s2_downloader.sh :

chmod +x s1_s2_downloader.sh

Ensuite, nous pouvons exécuter :

bash s1_s2_downloader.sh

En raison des conditions réseau, le traitement de certaines tuiles peut expirer. Notre script inclut une gestion sophistiquée des délais d'attente pour éviter ces problèmes. Cependant, parfois, certaines tuiles peuvent encore échouer. Exécuter à nouveau la commande ci-dessus résout généralement cela.

Si toutes les données Sentinel-1 et Sentinel-2 sont générées correctement, elles peuvent être empilées selon la dimension temporelle. Pour cette étape, nous utilisons deux exécutables générés en Rust, ce qui la rend très rapide. Vous pouvez ouvrir s1_s2_stacker.sh et modifier ce qui suit :

# === Basic Configuration ===
BASE_DIR="/absolute/path/to/your/data_dir"
OUT_DIR="${BASE_DIR}/data_processed"
DOWNSAMPLE_RATE=1

Normalement, nous ne modifions pas DOWNSAMPLE_RATE, ce qui l'empêche d'effectuer un sous-échantillonnage lors de l'empilement. Le BASE_DIR dans l'extrait ci-dessus est le même que le OUT_DIR que vous avez modifié dans s1_s2_downloader.sh.

De même, donnez la permission à s1_s2_stacker.sh :

chmod +x s1_s2_stacker.sh

Ensuite, vous pouvez exécuter l'empilement :

bash s1_s2_stacker.sh

Après réussite, vous obtiendrez des fichiers .npy dans /absolute/path/to/your/data_dir/data_processed. Généralement, ces fichiers .npy sont assez volumineux, nous allons donc les découper en unités plus petites et plus maniables.

Exécutez :

python dpixel_retiler.py \
    --tiff_path /absolute/path/to/your/data_dir/roi.tif \
    --d_pixel_dir /absolute/path/to/your/data_dir/data_processed \
    --patch_size 500 \
    --out_dir /absolute/path/to/your/data_dir/retiled_d_pixel \
    --num_workers 16 \
    --overwrite \
    --block_size 2000

Vous pouvez modifier vous-même les valeurs de patch_size et block_size ci-dessus. La configuration ci-dessus est une configuration recommandée pour un TIFF de forme (5000,5000) et une résolution de 10m.

Si le code ci-dessus s'exécute sans problème, vous pouvez obtenir des sous-dossiers dans my_data/retiled_d_pixel.

Inférence

Aperçu

Une fois le prétraitement des données terminé, nous pouvons commencer l'inférence. Avant de continuer, veuillez vérifier s'il y a des sous-dossiers dans le dossier my_data/retiled_d_pixel comme : 

retiled_d_pixel
 ┣ 0_3500_500_4000
 ┣ 0_4000_500_4500
 ┣ 0_4500_500_5000
 ┣ 0_5000_500_5500
 ┣ 0_5500_500_6000
 ┣ 0_6000_500_6500
Chaque sous-dossier doit contenir les fichiers suivants :

0_3500_500_4000
 ┣ bands.npy
 ┣ doys.npy
 ┣ masks.npy
 ┣ roi.tiff
 ┣ sar_ascending.npy
 ┣ sar_ascending_doy.npy
 ┣ sar_descending.npy
 ┗ sar_descending_doy.npy

Si ces fichiers existent, vous pouvez commencer l'inférence. Sinon, vérifiez si la première étape s'est déroulée avec succès.

L'inférence nécessite PyTorch. Étant donné que chaque système peut avoir des versions CUDA légèrement différentes, nous ne pouvons pas fournir un environnement Python encapsulé dans Docker comme nous l'avons fait pour le prétraitement des données. Heureusement, l'environnement Python pour l'inférence est beaucoup plus simple à configurer que pour le prétraitement des données, car il n'utilise pas de packages de traitement géographique tels que GDAL ou SNAP.

Préparation de Pytorch

Si vous n'avez pas installé Pytorch, vous pouvez vous référer aux étapes ci-dessous. Sinon, vous pouvez ignorer cette section.

Tout d'abord, vérifiez la version CUDA de votre système :

nvidia-smi

Puis rendez-vous sur https://pytorch.org/ et sélectionnez la version appropriée à installer en fonction de votre version CUDA, par exemple :

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

Poids du modèle

Ensuite, téléchargez les poids du modèle depuis Google Drive et placez le fichier .pt dans le répertoire tessera_infer/checkpoints :

tessera_infer
 ┗ checkpoints
     ┗ best_model_fsdp_20250427_084307.pt
 ┗ configs
 ┗ src

_Notez que le point de contrôle mentionné ci-dessus est un modèle en phase précoce, qui génère nativement des embeddings en float32. Par conséquent, ce modèle n’est pas celui utilisé pour générer les embeddings en int8 dans la bibliothèque geotessera. Nous déploierons bientôt le point de contrôle spécifique qui a été utilisé pour créer les embeddings geotessera dans l’ensemble du pipeline._

Configurer le script Bash

Pour simplifier la configuration de l’inférence, nous fournissons tessera_infer/infer_all_tiles.sh. Vous n’avez qu’à modifier quelques paramètres :

a. Répertoire de données de base : 

BASE_DATA_DIR="your_data_directory"
Ceci est votre dossier de stockage de données, identique à BASE_DATA_DIR dans le bash précédent, par exemple, /maps/usr/tessera_project/my_data

b. Environnement Python : 

export PYTHON_ENV="your_python_path"
Écrivez ici le chemin absolu vers votre environnement Python, par exemple, /home/user/anaconda3/envs/tessera_env/bin/python

c. Répartition CPU/GPU : 

CPU_GPU_SPLIT="1:1"  # Format: CPU:GPU ratio
Le script prend en charge l'inférence simultanée utilisant à la fois le CPU et le GPU. Ce ratio spécifie la proportion de retiled_patches que chaque appareil traitera. La valeur par défaut est 1:1 (répartition équitable). Pour une inférence uniquement GPU, définissez à 0:1.

d. Paramètres liés au CPU

MAX_CONCURRENT_PROCESSES_CPU=20
Nombre maximum de processus CPU pour l'inférence de tuiles. Par exemple, si réglé sur 20, il traitera 20 tuiles simultanément.

AVAILABLE_CORES=$((TOTAL_CPU_CORES / 2)) # Use 50% of the cores
Nombre de cœurs CPU à utiliser. Veuillez modifier cette valeur si nécessaire pour éviter de consommer trop de ressources CPU !

e. Paramètres liés au GPU : 

MAX_CONCURRENT_PROCESSES_GPU=1
Nombre maximal de processus GPU pour l'inférence. Si le système ne dispose que d'un seul GPU, réglez ceci sur 1.

GPU_BATCH_SIZE=1024  # Larger for GPU, if this takes too much memory, reduce it
Nombre d'échantillons à traiter simultanément lors de l'inférence PyTorch. Si cette valeur consomme trop de mémoire GPU ou provoque une erreur OOM sur le GPU, veuillez la réduire en conséquence.

f. Autres Paramètres D'autres paramètres sont disponibles pour la configuration. Veuillez les ajuster selon vos besoins.

Démarrer l'Inference

Une fois tout prêt, rendez-vous dans le dossier tessera_infer :

cd tessera_infer

Puis donnez la permission à infer_all_tiles.sh :

chmod +x infer_all_tiles.sh

Ensuite, exécutez-le :

bash infer_all_tiles.sh

Si cela réussit, vous devriez voir des journaux comme :

(base) zf281@daintree:/scratch/zf281/tessera_project/tessera_infer$ bash infer_all_tiles.sh
[INFO] Total CPU cores: 256, Using: 192
[INFO] CPU:GPU split ratio = 1:1 (total: 2)
==== SETUP DIRECTORIES ====
[SUCCESS] Created necessary directories
==== SCANNING TILES ====
[INFO] Tile directory: /scratch/zf281/jovana/retiled_d_pixel
[INFO] Output directory: /scratch/zf281/jovana/representation_retiled
[SUCCESS] Found 226 tiles total
[INFO] Sample tiles:
  
  • 0_3500_500_4000
    • 
  
  • 0_4000_500_4500
    • 
  
  • 0_4500_500_5000
    • 
  
  • ...

En même temps, un dossier logs sera généré dans le dossier tessera_infer avec des journaux plus détaillés pour chaque processus CPU et GPU.

Assembler la Carte de Représentation Finale

L'inférence prend généralement beaucoup de temps, selon la taille de votre ROI et les performances matérielles. Une fois terminée, vous pouvez trouver de nombreux fichiers .npy dans my_data/representation_retiled :

representation_retiled
 ┣ 0_3500_500_4000.npy
 ┣ 0_4000_500_4500.npy
 ┣ 0_4500_500_5000.npy
 ┣ 0_5000_500_5500.npy
 ┣ 0_5500_500_6000.npy
 ┣ 0_6000_500_6500.npy
 ┣ 0_6500_500_7000.npy
 ┣ 0_7000_500_7500.npy
 ┣ 1000_0_1500_500.npy
 ┣ 1000_1000_1500_1500.npy
 ┣ 1000_1500_1500_2000.npy
 ┣ 1000_2000_1500_2500.npy
La dernière étape consiste à les assembler à l'aide de tessera_infer/stitch_tiled_representation.py :

python stitch_tiled_representation.py \
--d_pixel_retiled_path /path/to/d_pixel_retiled \
--representation_retiled_path /path/to/representation_retiled \
--downstream_tiff /path/to/downstream.tiff \
--out_dir /path/to/output_directory
Par exemple :

python stitch_tiled_representation.py \
--d_pixel_retiled_path /maps/usr/tessera_project/my_data/d_pixel_retiled \
--representation_retiled_path /maps/usr/tessera_project/my_data/representation_retiled \
--downstream_tiff /maps/usr/tessera_project/my_data/downstream.tiff \
--out_dir /maps/usr/tessera_project/my_data
Enfin, vous obtiendrez une carte de représentation assemblée dans le répertoire my_data avec la forme (H,W,128), où H et W correspondent à votre roi.tiff initial. La carte de représentation est un tableau NumPy. Si vous souhaitez la convertir en TIFF pour la visualiser dans un logiciel comme QGIS, vous pouvez utiliser le script tessera_infer/convert_npy2tiff.py. Modifiez simplement la fonction principale avec :

npy_path = "/maps/usr/tessera_project/my_data/stitched_representation.npy"  # Change to the actual npy file path
ref_tiff_path = "/maps/usr/tessera_project/my_data/roi.tiff"  # Change to the actual reference tiff file path
out_dir = "/maps/usr/tessera_project/my_data/"  # Change to the actual output directory

Tâches en aval

Si vous souhaitez reproduire les tâches en aval présentées dans l'article, vous pouvez visiter https://github.com/ucam-eo/tessera-downstream-task. De nombreux exemples y sont fournis.

Informations supplémentaires

Équipe

Faculté de Cambridge

Postdoctorant

Doctorants

Étudiants de premier cycle

Stagiaires

Collaborateurs

Visiteurs

Contact

Veuillez adresser vos questions techniques à Frank Feng (zf281@cam.ac.uk) ou les poser sur notre forum Zulip. Les questions non techniques peuvent être envoyées au Prof. S. Keshav (sk818@cam.ac.uk).

Citation

Si vous utilisez TESSERA dans vos recherches, veuillez citer l’article arXiv :

@misc{feng2025tesseratemporalembeddingssurface,
      title={TESSERA: Temporal Embeddings of Surface Spectra for Earth Representation and Analysis}, 
      author={Zhengpeng Feng et al.},
      year={2025},
      eprint={2506.20380},
      archivePrefix={arXiv},
      primaryClass={cs.LG},
      url={https://arxiv.org/abs/2506.20380}, 
}

Remerciements

Nous souhaitons exprimer notre gratitude à UKRI et à l'équipe du superordinateur DAWN de Cambridge, pour leur soutien généreux dans ce projet. Nous remercions également le soutien de AMD, Vultr, de la Dirac High Performance Computing Facility, du Microsoft AI For Good Lab, du Dr Robert Sansom, de dClimate, et d'Amazon Web Services (AWS) dans le cadre de leur programme AWS Open Data (https://opendata.aws/). Ce travail n'aurait pas été possible sans leur soutien, leurs ressources informatiques et leur assistance technique. 

Historique des Étoiles

Graphique de l'Historique des Étoiles

AUP

Conditions d'Utilisation et Directives Éthiques de TESSERA

Licence

Les données et embeddings TESSERA sont mis à disposition sous la Licence Creative Commons 0 Internationale CC-0. Cela signifie que vous êtes libre de :

Objectif et Usages Prévus

TESSERA a été développé pour faire progresser la recherche scientifique et soutenir la surveillance environnementale, la conservation, l'agriculture durable et la compréhension des systèmes terrestres. Nous avons conçu cet outil pour permettre :

Directives Éthiques

Bien que la licence CC0 autorise un usage large, nous encourageons vivement les utilisateurs à considérer les implications éthiques de leur travail. Ces directives éthiques sont consultatives et n’imposent pas de restrictions légalement contraignantes. Nous demandons aux utilisateurs de :

Agir de manière responsable :

Être transparent : Soutenir un Impact Positif :

Caractéristiques des Données

Les utilisateurs doivent comprendre que TESSERA fournit :

Veuillez représenter ces caractéristiques avec exactitude dans votre travail.

Normes Communautaires

Nous encourageons une utilisation responsable et accueillons les retours de la communauté. Si vous avez des préoccupations concernant des applications potentielles ou des suggestions pour améliorer ces directives, veuillez nous contacter.

Nous nous réservons le droit de mettre à jour ces directives en fonction des retours de la communauté et des considérations émergentes, bien que ces mises à jour n’affectent pas rétroactivement la licence CC-0 sous laquelle les données sont publiées.

Contact

Pour questions ou retours : Email sk818@cam.ac.uk

---

Dernière mise à jour : 25 février 2026

--- Tranlated By Open Ai Tx | Last indexed: 2026-03-09 ---

Original README: View on GitHub

Translated by OpenAiTx | Last updated: 2026-03-09