Poverty example

.gitignore

@@ -33,6 +33,9 @@ examples/benchmarks/cifar-10/outputs/*
 dist/
 build/
 
+# Training / Inference outputs
+outputs/
+
 # Resources
 docs/resources/Amap_logo.png
 docs/resources/Malpolon_python_v2_image.png
@@ -48,4 +51,7 @@ examples/custom_train/sentinel-2a-rgbnir/test_bug_rasterio.md
 # Miscellaneous
 packages_malpolon.png
 classes_malpolon.png
-classes_yourpackage.png
+classes_yourpackage.png
+
+*.tif
+landsat_tiles/

README.md

@@ -1,4 +1,5 @@
 <p align="center">
+  <a href="https://arxiv.org/abs/2409.18102"><img src="https://img.shields.io/badge/arXiv-2409.18102-f9f107.svg" alt="arxiv paper"></a>
   <a href="https://pypi.org/project/malpolon/"><img src="https://img.shields.io/pypi/v/malpolon" alt="Python version"></a>
   <a href="https://www.python.org/downloads/release/python-3100/"><img src="https://img.shields.io/pypi/pyversions/malpolon" alt="Python version"></a>
   <a href="https://github.com/plantnet/malpolon/issues"><img src="https://img.shields.io/github/issues/plantnet/malpolon" alt="GitHub issues"></a>
@@ -32,9 +33,9 @@ Here is a list of the currently available scenarios:
 
 - [**Benchmarks**](examples/benchmarks/) : I want to compare the performance of different models on a given known dataset;\
   or I am a potential kaggle participant on the GeoLifeClef challenge. I want to train a model on the provided datasets without having to worry about the data loading, starting from a plug-and-play example.
-  - [<u>GeoLifeClef2022</u>](examples/benchmarks/geolifeclef2022/) : contains a fully functional example of a model training on the GeoLifeClef2022 dataset, from data download, to training and prediction.
-  - [<u>GeoLifeClef2023</u>](examples/benchmarks/geolifeclef2023/) : contains dataloaders for the GeoLifeClef2023 dataset (different from the GLC2022 dataloaders). The training and prediction scripts are not provided.
-  - [<u>GeoLifeClef2024 (pre-extracted)</u>](examples/benchmarks/geolifeclef2024_pre_extracted/) : contains a fully functional example of a multimodal ensemble model used to provide a strong baseline for the [GeoLifeClef2024 kaggle competition](https://www.kaggle.com/competitions/geolifeclef-2024). The example uses unique dataloaders and models to handle pre-extracted values from satellite patches, satellite time series and bioclimatic time series.
+  - [<u>GeoLifeClef2022</u>](examples/benchmarks/geolifeclef/geolifeclef2022/) : contains a fully functional example of a model training on the GeoLifeClef2022 dataset, from data download, to training and prediction.
+  - [<u>GeoLifeClef2023</u>](examples/benchmarks/geolifeclef/geolifeclef2023/) : contains dataloaders for the GeoLifeClef2023 dataset (different from the GLCgeolifeclef/2022 dataloaders). The training and prediction scripts are not provided.
+  - [<u>GeoLifeClef2024 (pre-extracted)</u>](examples/benchmarks/geolifeclef/geolifeclef2024_pre_extracted/) : contains a fully functional example of a multimodal ensemble model used to provide a strong baseline for the [GeoLifeClef2024 kaggle competition](https://www.kaggle.com/competitions/geolifeclef-2024). The example uses unique dataloaders and models to handle pre-extracted values from satellite patches, satellite time series and bioclimatic time series.
 - [**Train (custom datasets)**](examples/custom_train/) : I have a dataset of my own and I want to train a model on it. I want to be able to easily customize the training process and the model architecture.
   - <u>Drop and play</u> : I have an observations file (.csv) and I want to train a model on different environmental variables (rasters, satellite imagery) without having to worry about the data loading.
   - <u>Custom dataset</u> : I have my own dataset consisting of pre-extracted image patches and/or rasters and I want to train a model on it.

examples/.gitignore

@@ -1 +1,4 @@
 outputs
+
+landsat_tiles
+*.tif

examples/custom_train/sentinel-2a-rgbnir/cnn_on_rgbnir_torchgeo.py

@@ -8,8 +8,6 @@
 
 from __future__ import annotations
 
-import os
-
 import hydra
 import pytorch_lightning as pl
 from omegaconf import DictConfig

examples/custom_train/sentinel-2a-rgbnir/config/cnn_on_rgbnir_torchgeo_config.yaml

@@ -31,7 +31,7 @@ trainer:
   # gpus: 1  # Deprecated since pytorchlightning 1.7, removed in 2.0. Replaced by the 2 next attributes
   accelerator: "gpu"
   devices: 1
-  max_epochs: 3
+  max_epochs: 10
   # val_check_interval: 2
   check_val_every_n_epoch: 1
   log_every_n_steps: 10
@@ -78,6 +78,6 @@ optim:
     #   kwargs:
     #     num_classes: *num_classes
     multilabel_accuracy:
-      # callable: 'Fmetrics.classification.multilabel_accuracy'
+      callable: 'Fmetrics.classification.multilabel_accuracy'
       kwargs:
         num_labels: ${data.num_classes}

malpolon/data/datasets/__init__.py

@@ -4,7 +4,6 @@
 from .torchgeo_datasets import RasterTorchGeoDataset
 from .torchgeo_sentinel2 import RasterSentinel2
 from .torchgeo_concat import ConcatPatchRasterDataset
-
 __all__ = [
     "GeoLifeCLEF2022Dataset",
     "MiniGeoLifeCLEF2022Dataset",

malpolon/models/__init__.py

@@ -1,7 +1,9 @@
 from .standard_prediction_systems import (ClassificationSystem,
+                                          RegressionSystem,
                                           GenericPredictionSystem)
 
 __all__ = [  # noqa: F405
     "GenericPredictionSystem",
+    "RegressionSystem"
     "ClassificationSystem",
 ]

malpolon/models/custom_models/glc2024_pre_extracted_prediction_system.py

@@ -85,10 +85,10 @@ def __init__(
             loss_kwargs['pos_weight'] = Tensor([loss_kwargs['pos_weight']] * num_classes)
         super().__init__(model, optimizer=optimizer, metrics=metrics, task=task, loss_kwargs=loss_kwargs, hparams_preprocess=hparams_preprocess, checkpoint_path=checkpoint_path)
         if self.model.pretrained and not self.checkpoint_path:
-            self.download_weights("https://lab.plantnet.org/seafile/f/d780d4ab7f6b419194f9/?dl=1",
+            self.download_weights("https://lab.plantnet.org/seafile/f/755f49a508db4552b7db/?dl=1",
                                   weights_dir,
                                   filename="pretrained.ckpt",
-                                  md5="69111dd8013fcd8e8f4504def774f3a5")
+                                  md5="3c2c17d0781016cf71c231761ae73dcc")
 
     def forward(self, x, y, z):  # noqa: D102 pylint: disable=C0116
         return self.model(x, y, z)

malpolon/models/standard_prediction_systems.py

@@ -8,13 +8,16 @@
 
 from pathlib import Path
 from typing import TYPE_CHECKING
+import json
 
 import pytorch_lightning as pl
 import torch
 import torchmetrics.functional as Fmetrics
 from torchvision.datasets.utils import (download_and_extract_archive,
-                                        download_url)
+                                        download_url, extract_archive)
+import torchvision.models
 
+from torchmetrics.regression import R2Score
 from malpolon.models.utils import check_metric
 
 from .utils import check_loss, check_model, check_optimizer, check_scheduler
@@ -28,38 +31,34 @@
 class GenericPredictionSystem(pl.LightningModule):
     """Generic prediction system providing standard methods.
 
-
+    Parameters
+    ----------
+    model: torch.nn.Module
+        Model to use.
+    loss: torch.nn.modules.loss._Loss
+        Loss used to fit the model.
+    optimizer : Union[torch.optim.Optimizer, Mapping]
+            Optimization algorithm(s) used to train the model. There can be
+            several optimizers passed as an Omegaconf mapping.
+    scheduler : Union[torch.optim.Optimizer, Mapping], optional
+        Learning rate scheduler(s) used to train the model. There can be
+        several schedulers passed as an Omegaconf mapping., by default None
+    metrics: dict
+        Dictionary containing the metrics to monitor during the training and
+        to compute at test time.
+    save_hyperparameters: bool
+        Save arguments to hparams attribute.
     """
 
     def __init__(
         self,
         model: Union[torch.nn.Module, Mapping],
         loss: torch.nn.modules.loss._Loss,
-        optimizer: Union[torch.optim.Optimizer, Mapping],
+        optimizer: torch.optim.Optimizer,
         scheduler: Union[torch.optim.Optimizer] = None,
         metrics: Optional[dict[str, Callable]] = None,
         save_hyperparameters: Optional[bool] = True,
     ):
-        """Class constructor.
-
-        Parameters
-        ----------
-        model : Union[torch.nn.Module, Mapping]
-            Model to use.
-        loss : torch.nn.modules.loss._Loss
-             Loss used to fit the model.
-        optimizer : Union[torch.optim.Optimizer, Mapping]
-            Optimization algorithm(s) used to train the model. There can be
-            several optimizers passed as an Omegaconf mapping.
-        scheduler : Union[torch.optim.Optimizer, Mapping], optional
-            Learning rate scheduler(s) used to train the model. There can be
-            several schedulers passed as an Omegaconf mapping., by default None
-        metrics : Optional[dict[str, Callable]], optional
-            Dictionary containing the metrics to monitor during the training and
-            to compute at test time., by default None
-        save_hyperparameters : Optional[bool], optional
-            Save arguments to hparams attribute., by default True
-        """
         if save_hyperparameters:
             self.save_hyperparameters(ignore=['model', 'loss'])
         # Must be placed before the super call (or anywhere in other inheriting
@@ -159,12 +158,13 @@ def _step(
         x, y = batch
         y_hat = self(x)
 
-        loss = self.loss(y_hat, self._cast_type_to_loss(y))  # Shape mismatch for binary: need to 'y = y.unsqueeze(1)' (or use .reshape(2)) to cast from [2] to [2,1] and cast y to float with .float()
+        loss = self.loss(y_hat, self._cast_type_to_loss(
+            y))  # Shape mismatch for binary: need to 'y = y.unsqueeze(1)' (or use .reshape(2)) to cast from [2] to [2,1] and cast y to float with .float()
         self.log(f"loss/{split}", loss, **log_kwargs)
 
         for metric_name, metric_func in self.metrics.items():
             if isinstance(metric_func, dict):
-                score = metric_func['callable'](y_hat, y, **metric_func['kwargs'])
+                score = metric_func['callable'](y_hat, y, metric_func.get('kwargs', {}))
             else:
                 score = metric_func(y_hat, y)
             self.log(f"{metric_name}/{split}", score, **log_kwargs)
@@ -448,4 +448,66 @@ def __init__(
                              'kwargs': {}}
             }
 
-        super().__init__(model, loss, optimizer, metrics=metrics)
+        super().__init__(model, loss, optimizer, metrics)
+
+
+class RegressionSystem(GenericPredictionSystem):
+    """Regression task class."""
+    def __init__(
+        self,
+        model: Union[torch.nn.Module, Mapping],
+        optimizer: Union[torch.nn.Module, Mapping] = None,
+        lr: float = 1e-2,
+        weight_decay: float = 0,
+        metrics: Optional[dict[str, Callable]] = None,
+        task: str = 'regression',
+        hparams_preprocess: bool = True,
+    ):
+        """Class constructor.
+
+        Parameters
+        ----------
+        model : dict
+            model to use
+        lr : float
+            learning rate
+        weight_decay : float
+            weight decay
+        metrics : dict
+            dictionnary containing the metrics to compute.
+            Keys must match metrics' names and have a subkey with each
+            metric's functional methods as value. This subkey is either
+            created from the `malpolon.models.utils.FMETRICS_CALLABLES`
+            constant or supplied, by the user directly.
+        task : str, optional
+            Machine learning task (used to format labels accordingly),
+            by default 'regression'. The value determines
+            the loss to be selected.
+        hparams_preprocess : bool, optional
+            if True performs preprocessing operations on the hyperparameters,
+            by default True
+        """
+        if hparams_preprocess:
+            assert task == 'regression', "Regression task must be specified."
+            metrics = check_metric(metrics)
+
+        self.lr = lr
+        self.weight_decay = weight_decay
+
+        model = check_model(model)
+
+        if optimizer is None:
+            print(f'[INFO] No optimizer provided: using AdamW with lr={lr}, weight_decay={weight_decay}')
+            optimizer = torch.optim.AdamW(model.parameters(),
+                                          lr=lr,
+                                          weight_decay=weight_decay)
+
+        loss = torch.nn.MSELoss()
+
+        if metrics is None:
+            metrics = {
+                "regression_R2score": {'callable': Fmetrics.regression.r2_score,
+                                       'kwargs': {}}
+            }
+
+        super().__init__(model, loss, optimizer, metrics)

setup.py

@@ -1,8 +1,8 @@
 from setuptools import find_packages, setup
 
 setup(name="malpolon",
-      version="2.1.0",
-      description="Malpolon v2.1.0",
+      version="2.1.1",
+      description="Malpolon v2.1.1",
       author="Theo Larcher, Titouan Lorieul, Benjamin Deneu, Lukas Picek",
       author_email="theo.larcher@inria.fr, titouan.lorieul@gmail.com, benjamin.deneu@wsl.ch, lukas.picek@inria.fr",
       url="https://github.com/plantnet/malpolon",
@@ -22,7 +22,7 @@
         "Topic :: Scientific/Engineering :: GIS"
       ],
       packages=find_packages(
-       where="./",
+       where=".",
        include="malpolon*",
        exclude="malpolon.tests"),
       package_data={'malpolon.data.datasets._data': ['minigeolifeclef2022_species_details.csv']},