init

.gitattributes

@@ -0,0 +1,27 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zstandard filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "git.ignoreLimitWarning": true
+}

LICENSE.txt

@@ -0,0 +1,94 @@
+***
+CONTRAT DE LICENCE DE LOGICIEL
+
+Logiciel PFFL ©Inria 2020, tout droit réservé, ci-après dénommé "le Logiciel".
+
+Le Logiciel a été conçu et réalisé par des chercheurs de l’équipe-projet TITANE d’Inria (Institut National de Recherche en Informatique et Automatique).
+
+Inria, Domaine de Voluceau, Rocquencourt - BP 105
+78153 Le Chesnay Cedex, France
+
+Inria détient tous les droits de propriété sur le Logiciel.
+
+Le Logiciel a été déposé auprès de l'Agence pour la Protection des Programmes (APP) sous le numéro <numéro APP>.
+
+Le Logiciel est en cours de développement et Inria souhaite qu'il soit utilisé par la communauté scientifique de façon à le tester et l'évaluer, et afin qu’Inria puisse le cas échéant le faire évoluer.
+
+A cette fin, Inria a décidé de distribuer le Logiciel.
+
+Inria concède à l'utilisateur académique, gratuitement, sans droit de sous-licence, pour une période de un (1) an à compter du téléchargement du code source, le droit non-exclusif d'utiliser le Logiciel à fins de recherche. Toute autre utilisation sans l’accord préalable d’Inria est exclue.
+
+L’utilisateur académique reconnaît expressément avoir reçu d’Inria toutes les informations lui permettant d’apprécier l’adéquation du Logiciel à ses besoins et de prendre toutes les précautions utiles pour sa mise en œuvre et son utilisation.
+
+Le Logiciel est distribué sous forme d'un fichier source.
+
+Si le Logiciel est utilisé pour la publication de résultats, l’utilisateur devra citer le Logiciel de la façon suivante :
+
+@misc{girard2020polygonal,
+    title={Polygonal Building Segmentation by Frame Field Learning},
+    author={Nicolas Girard and Dmitriy Smirnov and Justin Solomon and Yuliya Tarabalka},
+    year={2020},
+    eprint={2004.14875},
+    archivePrefix={arXiv},
+    primaryClass={cs.CV}
+}
+
+
+Tout utilisateur du Logiciel pourra communiquer ses remarques d'utilisation du Logiciel aux développeurs de PFFL : [email protected]
+
+
+L'UTILISATEUR NE PEUT FAIRE NI UTILISATION NI EXPLOITATION NI DISTRIBUTION COMMERCIALE DU LOGICIEL SANS L'ACCORD EXPRÈS PRÉALABLE d’INRIA ([email protected]).
+TOUT ACTE CONTRAIRE CONSTITUERAIT UNE CONTREFAÇON.
+
+LE LOGICIEL EST FOURNI "TEL QU'EN L'ÉTAT" SANS AUCUNE GARANTIE DE QUELQUE NATURE, IMPLICITE OU EXPLICITE, QUANT À SON UTILISATION COMMERCIALE, PROFESSIONNELLE, LÉGALE OU NON, OU AUTRE, SA COMMERCIALISATION OU SON ADAPTATION.
+
+SAUF LORSQU'EXPLICITEMENT PRÉVU PAR LA LOI, INRIA NE POURRA ÊTRE TENU POUR RESPONSABLE DE TOUT DOMMAGE OU PRÉJUDICE DIRECT,INDIRECT, (PERTES FINANCIÈRES DUES AU MANQUE À GAGNER, À L'INTERRUPTION D'ACTIVITÉS OU À LA PERTE DE DONNÉES, ETC...) DÉCOULANT DE L'UTILISATION DE TOUT OU PARTIE DU LOGICIEL OU DE L'IMPOSSIBILITÉ D'UTILISER CELUI-CI.
+ 
+***
+
+SOFTWARE LICENSE AGREEMENT
+
+
+Software PFFL ©Inria – 2020, all rights reserved, hereinafter "the Software".
+
+This software has been developed by researchers of TITANE project team of Inria (Institut National de Recherche en Informatique et Automatique).
+
+Inria, Domaine de Voluceau, Rocquencourt - BP 105
+78153 Le Chesnay Cedex, FRANCE
+
+
+Inria holds all the ownership rights on the Software.
+
+The Software has been registered with the Agence pour la Protection des Programmes (APP) under <APP number>.
+
+The Software is still being currently developed. It is the Inria’s aim for the Software to be used by the scientific community so as to test it and, evaluate it so that Inria may improve it.
+
+For these reasons Inria has decided to distribute the Software.
+
+Inria grants to the academic user, a free of charge, without right to sublicense non-exclusive right to use the Software for research purposes for a period of one (1) year from the date of the download of the source code. Any other use without of prior consent of Inria is prohibited.
+
+The academic user explicitly acknowledges having received from Inria all information allowing him to appreciate the adequacy between of the Software and his needs and to undertake all necessary precautions for his execution and use.
+
+The Software is provided only as a source.
+
+In case of using the Software for a publication or other results obtained through the use of the Software, user should cite the Software as follows :
+
+@misc{girard2020polygonal,
+    title={Polygonal Building Segmentation by Frame Field Learning},
+    author={Nicolas Girard and Dmitriy Smirnov and Justin Solomon and Yuliya Tarabalka},
+    year={2020},
+    eprint={2004.14875},
+    archivePrefix={arXiv},
+    primaryClass={cs.CV}
+}
+
+
+Every user of the Software could communicate to the developers of PFFL [[email protected]] his or her remarks as to the use of the Software.
+
+THE USER CANNOT USE, EXPLOIT OR COMMERCIALY DISTRIBUTE THE SOFTWARE WITHOUT PRIOR AND EXPLICIT CONSENT OF INRIA ([email protected]). ANY SUCH ACTION WILL CONSTITUTE A FORGERY.
+
+THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTIES OF ANY NATURE AND ANY EXPRESS OR IMPLIED WARRANTIES,WITH REGARDS TO COMMERCIAL USE, PROFESSIONNAL USE, LEGAL OR NOT, OR OTHER, OR COMMERCIALISATION OR ADAPTATION.
+
+UNLESS EXPLICITLY PROVIDED BY LAW, IN NO EVENT, SHALL INRIA OR THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+

README.md

@@ -0,0 +1,13 @@
+---
+title: Luuu
+emoji: 🌍
+colorFrom: red
+colorTo: purple
+sdk: gradio
+sdk_version: 2.8.12
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference

app.py

@@ -0,0 +1,48 @@
+'''
+Author: Egrt
+Date: 2022-03-19 10:23:48
+LastEditors: Egrt
+LastEditTime: 2022-03-20 13:41:53
+FilePath: \Luuu\app.py
+'''
+
+from gis import GIS
+import gradio as gr
+import os
+os.system('pip install requirements.txt')
+from zipfile import ZipFile
+gis = GIS()
+
+
+# --------模型推理---------- #
+def inference(filepath):
+    filename, file_list = gis.detect_image(filepath)
+    with ZipFile("result.zip", "w") as zipObj:
+        zipObj.write(file_list[0], "{}.tif".format(filename+'mask'))
+        zipObj.write(file_list[1], "{}.tif".format(filename))
+        zipObj.write(file_list[2], "{}.pdf".format(filename))
+        zipObj.write(file_list[3], "{}.cpg".format(filename))
+        zipObj.write(file_list[4], "{}.dbf".format(filename))
+        zipObj.write(file_list[5], "{}.shx".format(filename))
+        zipObj.write(file_list[6], "{}.shp".format(filename))
+        zipObj.write(file_list[7], "{}.prj".format(filename))
+    return "images/result.zip"
+
+
+# --------网页信息---------- #  
+title = "基于帧场学习的多边形建筑提取"
+description = "目前最先进图像分割模型通常以栅格形式输出分割，但地理信息系统中的应用通常需要矢量多边形。我们在遥感图像中提取建筑物的任务中，将帧场输出添加到深度分割模型中，将预测的帧场与地面实况轮廓对齐，帮助减少深度网络输出与下游任务中输出样式之间的差距。  @Luuuu🐋🐋"
+article = "<p style='text-align: center'><a href='https://arxiv.org/abs/2004.14875' target='_blank'>Polygonization-by-Frame-Field-Learning</a> | <a href='https://github.com/JingyunLiang/SwinIR' target='_blank'>Github Repo</a></p>"
+example_img_dir  = 'images'
+example_img_name = os.listdir(example_img_dir)
+examples=[[os.path.join(example_img_dir, image_path)] for image_path in example_img_name if image_path.endswith('.png')]
+gr.Interface(
+    inference, 
+    [gr.inputs.Image(type="filepath", label="待检测图片")], 
+    gr.outputs.File(label="检测结果"),
+    title=title,
+    description=description,
+    article=article,
+    enable_queue=True,
+    examples=examples
+    ).launch(debug=True)

backbone.py

@@ -0,0 +1,71 @@
+import os
+
+import torch
+import torchvision
+
+from lydorn_utils import print_utils
+
+
+def get_backbone(backbone_params):
+    set_download_dir()
+    if backbone_params["name"] == "unet":
+        from torchvision.models.segmentation._utils import _SimpleSegmentationModel
+        from frame_field_learning.unet import UNetBackbone
+
+        backbone = UNetBackbone(backbone_params["input_features"], backbone_params["features"])
+        backbone = _SimpleSegmentationModel(backbone, classifier=torch.nn.Identity())
+    elif backbone_params["name"] == "fcn50":
+        backbone = torchvision.models.segmentation.fcn_resnet50(pretrained=backbone_params["pretrained"],
+                                                                num_classes=21)
+        backbone.classifier = torch.nn.Sequential(*list(backbone.classifier.children())[:-1],
+                                                  torch.nn.Conv2d(512, backbone_params["features"], kernel_size=(1, 1),
+                                                                  stride=(1, 1)))
+    elif backbone_params["name"] == "fcn101":
+        backbone = torchvision.models.segmentation.fcn_resnet101(pretrained=backbone_params["pretrained"],
+                                                                 num_classes=21)
+        backbone.classifier = torch.nn.Sequential(*list(backbone.classifier.children())[:-1],
+                                                  torch.nn.Conv2d(512, backbone_params["features"], kernel_size=(1, 1),
+                                                                  stride=(1, 1)))
+
+    elif backbone_params["name"] == "deeplab50":
+        backbone = torchvision.models.segmentation.deeplabv3_resnet50(pretrained=backbone_params["pretrained"],
+                                                                      num_classes=21)
+        backbone.classifier = torch.nn.Sequential(*list(backbone.classifier.children())[:-1],
+                                                  torch.nn.Conv2d(256, backbone_params["features"], kernel_size=(1, 1),
+                                                                  stride=(1, 1)))
+    elif backbone_params["name"] == "deeplab101":
+        backbone = torchvision.models.segmentation.deeplabv3_resnet101(pretrained=backbone_params["pretrained"],
+                                                                       num_classes=21)
+        backbone.classifier = torch.nn.Sequential(*list(backbone.classifier.children())[:-1],
+                                                  torch.nn.Conv2d(256, backbone_params["features"], kernel_size=(1, 1),
+                                                                  stride=(1, 1)))
+    elif backbone_params["name"] == "unet_resnet":
+        from torchvision.models.segmentation._utils import _SimpleSegmentationModel
+        from frame_field_learning.unet_resnet import UNetResNetBackbone
+
+        backbone = UNetResNetBackbone(backbone_params["encoder_depth"], num_filters=backbone_params["num_filters"],
+                                      dropout_2d=backbone_params["dropout_2d"],
+                                      pretrained=backbone_params["pretrained"],
+                                      is_deconv=backbone_params["is_deconv"])
+        backbone = _SimpleSegmentationModel(backbone, classifier=torch.nn.Identity())
+
+    elif backbone_params["name"] == "ictnet":
+        from torchvision.models.segmentation._utils import _SimpleSegmentationModel
+        from frame_field_learning.ictnet import ICTNetBackbone
+
+        backbone = ICTNetBackbone(in_channels=backbone_params["in_channels"],
+                                  out_channels=backbone_params["out_channels"],
+                                  preset_model=backbone_params["preset_model"],
+                                  dropout_2d=backbone_params["dropout_2d"],
+                                  efficient=backbone_params["efficient"])
+        backbone = _SimpleSegmentationModel(backbone, classifier=torch.nn.Identity())
+    else:
+        print_utils.print_error("ERROR: config[\"backbone_params\"][\"name\"] = \"{}\" is an unknown backbone!"
+                                "If it is a new backbone you want to use, "
+                                "add it in backbone.py's get_backbone() function.".format(backbone_params["name"]))
+        raise RuntimeError("Specified backbone {} unknown".format(backbone_params["name"]))
+    return backbone
+
+
+def set_download_dir():
+    os.environ['TORCH_HOME'] = 'models'  # setting the environment variable

child_processes.py

@@ -0,0 +1,76 @@
+import os
+
+import torch
+
+from lydorn_utils import python_utils
+from lydorn_utils import print_utils
+
+from backbone import get_backbone
+from dataset_folds import get_folds
+
+
+def train_process(gpu, config, shared_dict, barrier):
+    from frame_field_learning.train import train
+
+    print_utils.print_info("GPU {} -> Ready. There are {} GPU(s) available on this node.".format(gpu, torch.cuda.device_count()))
+
+    torch.manual_seed(0)  # Ensure same seed for all processes
+    # --- Find data directory --- #
+    root_dir_candidates = [os.path.join(data_dirpath, config["dataset_params"]["root_dirname"]) for data_dirpath in config["data_dir_candidates"]]
+    root_dir, paths_tried = python_utils.choose_first_existing_path(root_dir_candidates, return_tried_paths=True)
+    if root_dir is None:
+        print_utils.print_error("GPU {} -> ERROR: Data root directory amongst \"{}\" not found!".format(gpu, paths_tried))
+        exit()
+    print_utils.print_info("GPU {} -> Using data from {}".format(gpu, root_dir))
+
+    # --- Get dataset splits
+    # - CHANGE HERE TO ADD YOUR OWN DATASET
+    # We have to adapt the config["fold"] param to the folds argument of the get_folds function
+    fold = set(config["fold"])
+    if fold == {"train"}:
+        # Val will be used for evaluating the model after each epoch:
+        train_ds, val_ds = get_folds(config, root_dir, folds=["train", "val"])
+    elif fold == {"train", "val"}:
+        # Both train and val are meant to be used for training
+        train_ds, = get_folds(config, root_dir, folds=["train_val"])
+        val_ds = None
+    else:
+        # Should not arrive here since main makes sure config["fold"] is either one of the above
+        print_utils.print_error("ERROR: specified folds not recognized!")
+        raise NotImplementedError
+
+    # --- Instantiate backbone network
+    if config["backbone_params"]["name"] in ["deeplab50", "deeplab101"]:
+        assert 1 < config["optim_params"]["batch_size"], \
+            "When using backbone {}, batch_size has to be at least 2 for the batchnorm of the ASPPPooling to work."\
+                .format(config["backbone_params"]["name"])
+    backbone = get_backbone(config["backbone_params"])
+
+    # --- Launch training
+    train(gpu, config, shared_dict, barrier, train_ds, val_ds, backbone)
+
+
+def eval_process(gpu, config, shared_dict, barrier):
+    from frame_field_learning.evaluate import evaluate
+
+    torch.manual_seed(0)  # Ensure same seed for all processes
+    # --- Find data directory --- #
+    root_dir_candidates = [os.path.join(data_dirpath, config["dataset_params"]["root_dirname"]) for data_dirpath in
+                           config["data_dir_candidates"]]
+    root_dir, paths_tried = python_utils.choose_first_existing_path(root_dir_candidates, return_tried_paths=True)
+    if root_dir is None:
+        print_utils.print_error(
+            "GPU {} -> ERROR: Data root directory amongst \"{}\" not found!".format(gpu, paths_tried))
+        raise NotADirectoryError(f"Couldn't find a directory in {paths_tried} (gpu:{gpu})")
+    print_utils.print_info("GPU {} -> Using data from {}".format(gpu, root_dir))
+    config["data_root_dir"] = root_dir
+
+    # --- Get dataset
+    # - CHANGE HERE TO ADD YOUR OWN DATASET
+    eval_ds, = get_folds(config, root_dir, folds=config["fold"])  # config["fold"] is already a list (of length 1)
+
+    # --- Instantiate backbone network (its backbone will be used to extract features)
+    backbone = get_backbone(config["backbone_params"])
+
+    evaluate(gpu, config, shared_dict, barrier, eval_ds, backbone)
+

configs/README.md

@@ -0,0 +1,68 @@
+This folder stores all configuration variables used for launching training runs (and evaluating the results from those runs) in the form on config files.
+
+The ```main.py``` script has a ```--config``` argument which can be the path to any of the "config.*.json" files in this folder. Of course you can also write your own config file.
+Thus one "config.*.json" files points to all parameters used for the run.
+
+As we perform quite a lot of different experiments requiring only a few parameters to change, I have setup a hierarchical system of config files allowing default values that can be overwritten.
+This way a single parameter can be shared by all experiments and can be changed for all of them by modifying it in only one location.
+A config is stored as a JSON dictionary. This config dictionary can store nested dictionaries of parameters. 
+Whenever the "defaults_filepath" key is used in a config file, 
+its value is assumed to be the path to another config file whose dictionary is loaded and merged with the dictionary that had the "defaults_filepath" key.
+The keys alongside the "defaults_filepath" key specify parameters that should overwrite the default values loaded from the "defaults_filepath" config file.
+
+To illustrate how this works, let's say the config folder looks like this:
+```
+config 
+|-- config.defaults.json
+`-- config.my_exp_1.json
+`-- config.my_exp_2.json
+```
+ 
+Let's say config.defaults.json is:
+```json
+{
+  "learning_rate": 0.1,
+  "batch_size": 16
+}
+```  
+
+And config.my_exp_1.json is:
+```json
+{
+  "defaults_filepath": "configs/config.defaults.json"
+}
+```
+
+And config.my_exp_2.json is:
+```json
+{
+  "defaults_filepath": "configs/config.defaults.json",
+  
+  "learning_rate": 0.01
+  
+}
+```
+
+When loaded by the ```main.py``` script, they will be expanded into the following.
+
+config.my_exp_1.json:
+```json
+{
+  "learning_rate": 0.1,
+  "batch_size": 16
+}
+```
+
+config.my_exp_2.json:
+```json
+{
+  "learning_rate": 0.01,
+  "batch_size": 16
+  
+}
+```
+
+When a lot of parameters are used by the actual config files we used, it is thus very easy to know that all "my_exp_2" does is change the learning rate.
+Also if we want to change the batch size for all experiments, all we have to do is change its value in "config.defaults.json".
+This principle of using the "defaults_filepath" key to point to another config file can be used in nested dictionary parameters as well.
+A config file is thus the root of a config tree loaded recursively.

configs/backbone_params.deeplab101.json

@@ -0,0 +1,6 @@
+{
+    "name": "deeplab101",
+    "input_features": 3,
+    "features": 128,
+    "pretrained": false
+}

configs/backbone_params.deeplab50.json

@@ -0,0 +1,6 @@
+{
+    "name": "deeplab50",
+    "input_features": 3,
+    "features": 128,
+    "pretrained": false
+}

configs/backbone_params.fcn101.json

@@ -0,0 +1,6 @@
+{
+    "name": "fcn101",
+    "input_features": 3,
+    "features": 256,
+    "pretrained": false
+}

configs/backbone_params.fcn50.json

@@ -0,0 +1,6 @@
+{
+    "name": "fcn50",
+    "input_features": 3,
+    "features": 256,
+    "pretrained": false
+}

configs/backbone_params.ictnet.json

@@ -0,0 +1,8 @@
+{
+    "name": "ictnet",
+    "preset_model": "FC-DenseNet103",  // FC-DenseNet56, FC-DenseNet67 and FC-DenseNet103 are possible
+    "in_channels": 3,
+    "out_channels": 32,
+    "dropout_2d": 0.0,  // Default: 0.2
+    "efficient": true  // If true, use gradient checkpointing to reduce memory at the expense of some speed
+}

configs/backbone_params.unet16.json

@@ -0,0 +1,5 @@
+{
+    "name": "unet",
+    "input_features": 3,
+    "features": 16
+}

configs/backbone_params.unet_resnet101.json

@@ -0,0 +1,9 @@
+{
+    "name": "unet_resnet",
+    "encoder_depth": 101,  // 34, 101 and 152 are possible
+    "input_features": 3,
+    "num_filters": 32,  // Default: 32
+    "pretrained": false,
+    "dropout_2d": 0.2,  // Default: 0.2
+    "is_deconv": false // Default: false
+}

configs/config.defaults.inria_dataset_osm_aligned.json

@@ -0,0 +1,15 @@
+{
+  "defaults_filepath": "configs/config.defaults.json",
+
+  "dataset_params": {
+    "defaults_filepath": "configs/dataset_params.inria_dataset_osm_aligned.json"  // Path from the project's root to a JSON with default values for dataset_params
+  },
+
+  "eval_params" : {
+    "defaults_filepath": "configs/eval_params.inria_dataset.json"  // Path from the project's root to a JSON with default values for eval_params
+  },
+
+  "optim_params": {
+    "gamma": 0.99
+  }
+}

configs/config.defaults.inria_dataset_osm_mask_only.json

@@ -0,0 +1,21 @@
+{
+  "defaults_filepath": "configs/config.defaults.json",
+
+  "dataset_params": {
+    "defaults_filepath": "configs/dataset_params.inria_dataset_osm_mask_only.json"  // Path from the project's root to a JSON with default values for dataset_params
+  },
+
+  "eval_params" : {
+    "defaults_filepath": "configs/eval_params.inria_dataset.json"  // Path from the project's root to a JSON with default values for eval_params
+  },
+
+  "optim_params": {
+    "gamma": 0.99
+  },
+
+  "data_aug_params": {
+    "color_jitter": false
+  },
+
+  "compute_seg": false
+}

configs/config.defaults.inria_dataset_polygonized.json

@@ -0,0 +1,15 @@
+{
+  "defaults_filepath": "configs/config.defaults.json",
+
+  "dataset_params": {
+    "defaults_filepath": "configs/dataset_params.inria_dataset_polygonized.json"  // Path from the project's root to a JSON with default values for dataset_params
+  },
+
+  "eval_params" : {
+    "defaults_filepath": "configs/eval_params.inria_dataset.json"  // Path from the project's root to a JSON with default values for eval_params
+  },
+
+  "optim_params": {
+    "gamma": 0.99
+  }
+}

configs/config.defaults.inria_dataset_polygonized_256.json

@@ -0,0 +1,15 @@
+{
+  "defaults_filepath": "configs/config.defaults.json",
+
+  "dataset_params": {
+    "defaults_filepath": "configs/dataset_params.inria_dataset_polygonized_256.json"  // Path from the project's root to a JSON with default values for dataset_params
+  },
+
+  "eval_params" : {
+    "defaults_filepath": "configs/eval_params.inria_dataset.json"  // Path from the project's root to a JSON with default values for eval_params
+  },
+
+  "optim_params": {
+    "gamma": 0.99
+  }
+}

configs/config.defaults.json

@@ -0,0 +1,40 @@
+{
+  "data_dir_candidates": [
+    "/data/titane/user/nigirard/data",
+    "~/data",
+    "/data"
+  ],
+  "num_workers": null,  // If null, will use multiprocess.cpu_count() workers in total
+  "data_aug_params": {
+    "enable": true,
+    "vflip": true,
+    "affine": true,
+    "scaling": [0.75, 1.5],  // Range of scaling factor to apply during affine transform. Set to None to not apply.
+    "color_jitter": true,
+    "device": "cuda"
+  },
+
+  "device": "cuda",  // Only has effects when mode is val or test. When mode is train, always use CUDA
+  "use_amp": false,  // Automatic Mixed Precision switch
+
+  "compute_seg": true,
+  "compute_crossfield": true,
+
+  "seg_params": {
+    "compute_interior": true,
+    "compute_edge": true,
+    "compute_vertex": false
+  },
+
+  "loss_params": {
+    "defaults_filepath": "configs/loss_params.json"  // Path from the project's root to a JSON with default values for dataset_params
+  },
+
+  "optim_params": {
+    "defaults_filepath": "configs/optim_params.json"  // Path from the project's root to a JSON with default values for optim_params
+  },
+
+  "polygonize_params": {
+    "defaults_filepath": "configs/polygonize_params.json"  // Path from the project's root to a JSON with default values for polygonize_params
+  }
+}

configs/config.defaults.luxcarta_dataset.json

@@ -0,0 +1,11 @@
+{
+  "defaults_filepath": "configs/config.defaults.json",
+
+  "dataset_params": {
+    "defaults_filepath": "configs/dataset_params.luxcarta_dataset.json"  // Path from the project's root to a JSON with default values for dataset_params
+  },
+
+  "eval_params" : {
+    "defaults_filepath": "configs/eval_params.luxcarta_dataset.json"  // Path from the project's root to a JSON with default values for eval_params
+  }
+}

configs/config.defaults.mapping_dataset.json

@@ -0,0 +1,11 @@
+{
+  "defaults_filepath": "configs/config.defaults.json",
+
+  "dataset_params": {
+    "defaults_filepath": "configs/dataset_params.mapping_dataset.json"  // Path from the project's root to a JSON with default values for dataset_params
+  },
+
+  "eval_params" : {
+    "defaults_filepath": "configs/eval_params.mapping_dataset.json"  // Path from the project's root to a JSON with default values for eval_params
+  }
+}

configs/config.defaults.xview2_dataset.json

@@ -0,0 +1,15 @@
+{
+  "defaults_filepath": "configs/config.defaults.json",
+
+  "dataset_params": {
+    "defaults_filepath": "configs/dataset_params.xview2_dataset.json"  // Path from the project's root to a JSON with default values for dataset_params
+  },
+
+  "eval_params" : {
+    "defaults_filepath": "configs/eval_params.xview2_dataset.json"  // Path from the project's root to a JSON with default values for eval_params
+  },
+
+  "optim_params": {
+    "gamma": 0.99
+  }
+}

configs/config.inria_dataset_osm_aligned.unet_resnet101_pretrained.field_off.json

@@ -0,0 +1,24 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset_osm_aligned.json",
+
+  "run_name": "inria_dataset_osm_aligned.unet_resnet101_pretrained.field_off",
+
+  "compute_crossfield": false,
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.unet_resnet101.json",  // Path from the project's root to a JSON with default values for backbone_params
+    "pretrained": true
+  },
+
+  "loss_params": {
+    "seg_loss_params": {
+      "use_size": false
+    }
+  },
+
+ "optim_params": {
+    "optimizer": "RMSProp",
+    "gamma": 0.99,
+    "batch_size": 3  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.inria_dataset_osm_aligned.unet_resnet101_pretrained.json

@@ -0,0 +1,24 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset_osm_aligned.json",
+
+  "run_name": "inria_dataset_osm_aligned.unet_resnet101_pretrained",
+
+
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.unet_resnet101.json",  // Path from the project's root to a JSON with default values for backbone_params
+    "pretrained": true
+  },
+
+  "loss_params": {
+    "seg_loss_params": {
+      "use_size": false
+    }
+  },
+
+ "optim_params": {
+    "optimizer": "RMSProp",
+    "gamma": 0.99,
+    "batch_size": 3  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.inria_dataset_osm_mask_only.unet16.json

@@ -0,0 +1,17 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset_osm_mask_only.json",
+
+  "run_name": "inria_dataset_osm_mask_only.unet16",
+
+
+
+
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.unet16.json"  // Path from the project's root to a JSON with default values for backbone_params
+  },
+
+  "optim_params": {
+    "batch_size": 16  // Batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.inria_dataset_polygonized.ictnet.leaderboard.json

@@ -0,0 +1,38 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset_polygonized.json",
+
+  "run_name": "inria_dataset_polygonized.ictnet.leaderboard",
+
+
+
+
+
+
+
+  "seg_params": {
+    "compute_interior": true,
+    "compute_edge": false,
+    "compute_vertex": false
+  },
+
+
+
+
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.ictnet.json"  // Path from the project's root to a JSON with default values for backbone_params
+  },
+
+  "loss_params": {
+    "seg_loss_params": {
+      "bce_coef": 1.0,
+      "dice_coef": 0.2,
+      "use_dist": true,  // Dist weights as in the original U-Net paper
+      "use_size": false  // Size weights increasing importance of smaller buildings
+    }
+  },
+
+  "optim_params": {
+    "batch_size": 2  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.inria_dataset_polygonized.ictnet.rmsprop.leaderboard.field_off.json

@@ -0,0 +1,39 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset_polygonized.json",
+
+  "run_name": "inria_dataset_polygonized.ictnet.rmsprop.leaderboard.field_off",
+
+  "compute_crossfield": false,
+
+
+
+
+
+  "seg_params": {
+    "compute_interior": true,
+    "compute_edge": false,
+    "compute_vertex": false
+  },
+
+
+
+
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.ictnet.json"  // Path from the project's root to a JSON with default values for backbone_params
+  },
+
+  "loss_params": {
+    "seg_loss_params": {
+      "bce_coef": 1.0,
+      "dice_coef": 0.2,
+      "use_dist": true,  // Dist weights as in the original U-Net paper
+      "use_size": false  // Size weights increasing importance of smaller buildings
+    }
+  },
+
+  "optim_params": {
+    "optimizer": "RMSProp",
+    "batch_size": 2  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.inria_dataset_polygonized.ictnet.rmsprop.leaderboard.json

@@ -0,0 +1,39 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset_polygonized.json",
+
+  "run_name": "inria_dataset_polygonized.ictnet.rmsprop.leaderboard",
+
+
+
+
+
+
+
+  "seg_params": {
+    "compute_interior": true,
+    "compute_edge": false,
+    "compute_vertex": false
+  },
+
+
+
+
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.ictnet.json"  // Path from the project's root to a JSON with default values for backbone_params
+  },
+
+  "loss_params": {
+    "seg_loss_params": {
+      "bce_coef": 1.0,
+      "dice_coef": 0.2,
+      "use_dist": true,  // Dist weights as in the original U-Net paper
+      "use_size": false  // Size weights increasing importance of smaller buildings
+    }
+  },
+
+  "optim_params": {
+    "optimizer": "RMSProp",
+    "batch_size": 2  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.inria_dataset_polygonized.unet_resnet101.leaderboard.json

@@ -0,0 +1,33 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset_polygonized.json",
+
+  "run_name": "inria_dataset_polygonized.unet_resnet101.leaderboard",
+
+  "seg_params": {
+    "compute_interior": true,
+    "compute_edge": false,
+    "compute_vertex": false
+  },
+
+
+
+
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.unet_resnet101.json",  // Path from the project's root to a JSON with default values for backbone_params
+    "pretrained": false
+  },
+
+  "loss_params": {
+    "seg_loss_params": {
+      "bce_coef": 1.0,
+      "dice_coef": 0.2,
+      "use_dist": true,  // Dist weights as in the original U-Net paper
+      "use_size": false  // Size weights increasing importance of smaller buildings
+    }
+  },
+
+  "optim_params": {
+    "batch_size": 4  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.inria_dataset_polygonized.unet_resnet101_pretrained.field_off.json

@@ -0,0 +1,18 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset_polygonized.json",
+
+  "run_name": "inria_dataset_polygonized.unet_resnet101_pretrained.field_off",
+
+  "compute_crossfield": false,
+
+
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.unet_resnet101.json",  // Path from the project's root to a JSON with default values for backbone_params
+    "pretrained": true
+  },
+
+   "optim_params": {
+    "batch_size": 10  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.inria_dataset_polygonized.unet_resnet101_pretrained.json

@@ -0,0 +1,18 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset_polygonized.json",
+
+  "run_name": "inria_dataset_polygonized.unet_resnet101_pretrained",
+
+
+
+
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.unet_resnet101.json",  // Path from the project's root to a JSON with default values for backbone_params
+    "pretrained": true
+  },
+
+   "optim_params": {
+    "batch_size": 10  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.inria_dataset_polygonized.unet_resnet101_pretrained.leaderboard.field_off.json

@@ -0,0 +1,35 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset_polygonized.json",
+
+  "run_name": "inria_dataset_polygonized.unet_resnet101_pretrained.leaderboard.field_off",
+
+  "compute_crossfield": false,
+
+  "seg_params": {
+    "compute_interior": true,
+    "compute_edge": false,
+    "compute_vertex": false
+  },
+
+
+
+
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.unet_resnet101.json",  // Path from the project's root to a JSON with default values for backbone_params
+    "pretrained": true
+  },
+
+  "loss_params": {
+    "seg_loss_params": {
+      "bce_coef": 1.0,
+      "dice_coef": 0.2,
+      "use_dist": true,  // Dist weights as in the original U-Net paper
+      "use_size": false  // Size weights increasing importance of smaller buildings
+    }
+  },
+
+  "optim_params": {
+    "batch_size": 4  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.inria_dataset_polygonized.unet_resnet101_pretrained.leaderboard.json

@@ -0,0 +1,35 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset_polygonized.json",
+
+  "run_name": "inria_dataset_polygonized.unet_resnet101_pretrained.leaderboard",
+
+
+
+  "seg_params": {
+    "compute_interior": true,
+    "compute_edge": false,
+    "compute_vertex": false
+  },
+
+
+
+
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.unet_resnet101.json",  // Path from the project's root to a JSON with default values for backbone_params
+    "pretrained": true
+  },
+
+  "loss_params": {
+    "seg_loss_params": {
+      "bce_coef": 1.0,
+      "dice_coef": 0.2,
+      "use_dist": true,  // Dist weights as in the original U-Net paper
+      "use_size": false  // Size weights increasing importance of smaller buildings
+    }
+  },
+
+  "optim_params": {
+    "batch_size": 4  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.inria_dataset_polygonized_small.unet_resnet101_pretrained.json

@@ -0,0 +1,19 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset_polygonized.json",
+
+  "run_name": "inria_dataset_polygonized_small.unet_resnet101_pretrained",
+
+  "dataset_params": {
+    "small": true
+  },
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.unet_resnet101.json",  // Path from the project's root to a JSON with default values for backbone_params
+    "pretrained": true
+  },
+
+   "optim_params": {
+    "batch_size": 10,  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+    "gamma": 1.0
+  }
+}

configs/config.inria_dataset_polygonized_small.unet_resnet101_pretrained.no_aug.json

@@ -0,0 +1,23 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset_polygonized.json",
+
+  "run_name": "inria_dataset_polygonized_small.unet_resnet101_pretrained.no_aug",
+
+  "dataset_params": {
+    "small": true
+  },
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.unet_resnet101.json",  // Path from the project's root to a JSON with default values for backbone_params
+    "pretrained": true
+  },
+
+   "optim_params": {
+    "gamma": 1.0,
+    "log_steps": 10
+  },
+
+  "data_aug_params": {
+    "enable": false
+  }
+}

configs/config.inria_dataset_small.unet16.json

@@ -0,0 +1,19 @@
+{
+  "defaults_filepath": "configs/config.defaults.inria_dataset.json",
+
+  "run_name": "inria_dataset_small.unet16",
+
+  "dataset_params": {
+    "small": true
+  },
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.unet16.json"  // Path from the project's root to a JSON with default values for backbone_params
+
+  },
+
+  "optim_params": {
+    "batch_size": 12,  // Batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+    "gamma": 0.99
+  }
+}

configs/config.luxcarta_dataset.unet16.field_off.json

@@ -0,0 +1,15 @@
+{
+  "defaults_filepath": "configs/config.defaults.luxcarta_dataset.json",
+
+  "run_name": "luxcarta_dataset.unet16.field_off",
+
+  "compute_crossfield": false,
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.unet16.json"  // Path from the project's root to a JSON with default values for backbone_params
+  },
+
+  "optim_params": {
+    "batch_size": 16  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.luxcarta_dataset.unet16.json

@@ -0,0 +1,15 @@
+{
+  "defaults_filepath": "configs/config.defaults.luxcarta_dataset.json",
+
+  "run_name": "luxcarta_dataset.unet16",
+
+
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.unet16.json"  // Path from the project's root to a JSON with default values for backbone_params
+  },
+
+  "optim_params": {
+    "batch_size": 16  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.mapping_dataset.asip.json

@@ -0,0 +1,5 @@
+{
+  "defaults_filepath": "configs/config.defaults.mapping_dataset.json",
+
+  "run_name": "mapping_dataset.asip"
+}

configs/config.mapping_dataset.deeplab101.field_off.json

@@ -0,0 +1,15 @@
+{
+  "defaults_filepath": "configs/config.defaults.mapping_dataset.json",
+
+  "run_name": "mapping_dataset.deeplab101.field_off",
+
+  "compute_crossfield": false,
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.deeplab101.json"  // Path from the project's root to a JSON with default values for backbone_params
+  },
+
+  "optim_params": {
+    "batch_size": 8  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.mapping_dataset.deeplab101.field_off.train_val.json

@@ -0,0 +1,16 @@
+{
+  "defaults_filepath": "configs/config.defaults.mapping_dataset.json",
+
+  "run_name": "mapping_dataset.deeplab101.field_off.train_val",
+  "fold": ["train", "val"],
+
+  "compute_crossfield": false,
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.deeplab101.json"  // Path from the project's root to a JSON with default values for backbone_params
+  },
+
+  "optim_params": {
+    "batch_size": 8  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.mapping_dataset.deeplab101.json

@@ -0,0 +1,16 @@
+{
+  "defaults_filepath": "configs/config.defaults.mapping_dataset.json",
+
+  "run_name": "mapping_dataset.deeplab101",
+
+
+
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.deeplab101.json"  // Path from the project's root to a JSON with default values for backbone_params
+  },
+
+  "optim_params": {
+    "batch_size": 8  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.mapping_dataset.deeplab101.train_val.json

@@ -0,0 +1,15 @@
+{
+  "defaults_filepath": "configs/config.defaults.mapping_dataset.json",
+
+  "run_name": "mapping_dataset.deeplab101.train_val",
+  "fold": ["train", "val"],
+
+
+  "backbone_params": {
+    "defaults_filepath": "configs/backbone_params.deeplab101.json"  // Path from the project's root to a JSON with default values for backbone_params
+  },
+
+  "optim_params": {
+    "batch_size": 8  // Overwrite default batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  }
+}

configs/config.mapping_dataset.fcn101.json

@@ -0,0 +1,89 @@
+{
+  "run_name": "mapping_dataset.fcn50",
+
+  "data_dir_candidates": [
+    "/local/shared/data", // try cluster local node first
+    "/data/titane/user/nigirard/data", // Try cluster /data directory
+    "~/data", // In home directory (docker)
+    "/data" // In landsat's /data volume (docker)
+  ],
+  "data_root_partial_dirpath": "mapping_challenge_dataset",
+  "dataset_params": {
+    "small": false
+  },
+  "num_workers": 10,
+  "data_split_params": {
+    "seed": 0,  // Change this to change the random splitting of data in train/val/test
+    "train_fraction": 0.75,
+    "val_fraction": 0.25 // test_fraction is the rest
+  },
+  "data_aug_params": {
+    "enable": true,
+    "vflip": true,
+    "rotate": true,
+    "color_jitter": true,
+    "device": "cuda"
+  },
+
+  "device": "cuda",  // Only has effects when mode is val or test. When mode is train, always use CUDA
+  "use_amp": true,  // Automatic Mixed Precision switch
+
+  "backbone_params": {
+    "name": "fcn101",
+    "input_features": 3,
+    "features": 256,
+    "pretrained": false
+  },
+
+  "compute_seg": true,
+  "compute_crossfield": true,
+
+  "seg_params": {
+    "compute_interior": true,
+    "compute_edge": true,
+    "compute_vertex": false
+  },
+
+  "loss_params": {
+    "multiloss": {
+      "normalization_params": {
+        "min_samples": 10,  // Per GPU
+        "max_samples": 1000  // Per GPU
+      },
+      "coefs": {
+        "seg_interior": 1,
+        "seg_edge": 1,
+        "seg_vertex": 0,
+        "crossfield_align": 1,
+        "crossfield_align90": 0.2,
+        "crossfield_smooth": 0.2,
+        "seg_interior_crossfield": 0.2,
+        "seg_edge_crossfield": 0.2,
+        "seg_edge_interior": 0.2
+      }
+    },
+    "seg_loss_params": {  // https://github.com/neptune-ai/open-solution-mapping-challenge/blob/master/neptune.yaml
+      "bce_coef": 1.0,
+      "dice_coef": 0.2,
+      "w0": 50,  // From original U-Net paper: distance weight to increase loss between objects
+      "sigma": 10  // From original U-Net paper: distance weight to increase loss between objects
+    }
+  },
+
+  "batch_size": 12,  // Batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  "base_lr": 1e-4,  // Will be multiplied by the effective_batch_size=world_size*batch_size.
+  "max_lr": 1e-2,  // Maximum learning rate
+  "warmup_epochs": 1,  // Number of epochs for warmup (learning rate starts at lr*warmup_factor and gradually increases to lr)
+  "warmup_factor": 1e-3,
+  "weight_decay": 0,
+  "dropout_keep_prob": 1.0,  // Not used for now
+  "max_epoch": 25,
+  "log_steps": 50,
+  "checkpoint_epoch": 1,
+  "checkpoints_to_keep": 10,  // outputs
+  "logs_dirname": "logs",
+  "save_input_output": false,
+  "log_input_output": false,
+  "checkpoints_dirname": "checkpoints",
+  "eval_dirname": "eval"
+}

configs/config.mapping_dataset.fcn50.json

@@ -0,0 +1,89 @@
+{
+  "run_name": "mapping_dataset.fcn50",
+
+  "data_dir_candidates": [
+    "/local/shared/data", // try cluster local node first
+    "/data/titane/user/nigirard/data", // Try cluster /data directory
+    "~/data", // In home directory (docker)
+    "/data" // In landsat's /data volume (docker)
+  ],
+  "data_root_partial_dirpath": "mapping_challenge_dataset",
+  "dataset_params": {
+    "small": false
+  },
+  "num_workers": 10,
+  "data_split_params": {
+    "seed": 0,  // Change this to change the random splitting of data in train/val/test
+    "train_fraction": 0.75,
+    "val_fraction": 0.25 // test_fraction is the rest
+  },
+  "data_aug_params": {
+    "enable": true,
+    "vflip": true,
+    "rotate": true,
+    "color_jitter": true,
+    "device": "cuda"
+  },
+
+  "device": "cuda",  // Only has effects when mode is val or test. When mode is train, always use CUDA
+  "use_amp": true,  // Automatic Mixed Precision switch
+
+  "backbone_params": {
+    "name": "fcn50",
+    "input_features": 3,
+    "features": 256,
+    "pretrained": false
+  },
+
+  "compute_seg": true,
+  "compute_crossfield": true,
+
+  "seg_params": {
+    "compute_interior": true,
+    "compute_edge": true,
+    "compute_vertex": false
+  },
+
+  "loss_params": {
+    "multiloss": {
+      "normalization_params": {
+        "min_samples": 10,  // Per GPU
+        "max_samples": 1000  // Per GPU
+      },
+      "coefs": {
+        "seg_interior": 1,
+        "seg_edge": 1,
+        "seg_vertex": 0,
+        "crossfield_align": 1,
+        "crossfield_align90": 0.2,
+        "crossfield_smooth": 0.2,
+        "seg_interior_crossfield": 0.2,
+        "seg_edge_crossfield": 0.2,
+        "seg_edge_interior": 0.2
+      }
+    },
+    "seg_loss_params": {  // https://github.com/neptune-ai/open-solution-mapping-challenge/blob/master/neptune.yaml
+      "bce_coef": 1.0,
+      "dice_coef": 0.2,
+      "w0": 50,  // From original U-Net paper: distance weight to increase loss between objects
+      "sigma": 10  // From original U-Net paper: distance weight to increase loss between objects
+    }
+  },
+
+  "batch_size": 16,  // Batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  "base_lr": 1e-4,  // Will be multiplied by the effective_batch_size=world_size*batch_size.
+  "max_lr": 1e-2,  // Maximum learning rate
+  "warmup_epochs": 1,  // Number of epochs for warmup (learning rate starts at lr*warmup_factor and gradually increases to lr)
+  "warmup_factor": 1e-3,
+  "weight_decay": 0,
+  "dropout_keep_prob": 1.0,  // Not used for now
+  "max_epoch": 25,
+  "log_steps": 50,
+  "checkpoint_epoch": 1,
+  "checkpoints_to_keep": 10,  // outputs
+  "logs_dirname": "logs",
+  "save_input_output": false,
+  "log_input_output": false,
+  "checkpoints_dirname": "checkpoints",
+  "eval_dirname": "eval"
+}

configs/config.mapping_dataset.open_solution.json

@@ -0,0 +1,5 @@
+{
+  "defaults_filepath": "configs/config.defaults.mapping_dataset.json",
+
+  "run_name": "mapping_dataset.open_solution"
+}

configs/config.mapping_dataset.open_solution_full.json

@@ -0,0 +1,5 @@
+{
+  "defaults_filepath": "configs/config.defaults.mapping_dataset.json",
+
+  "run_name": "mapping_dataset.open_solution_full"
+}

configs/config.mapping_dataset.polymapper.json

@@ -0,0 +1,5 @@
+{
+  "defaults_filepath": "configs/config.defaults.mapping_dataset.json",
+
+  "run_name": "mapping_dataset.polymapper"
+}

configs/config.mapping_dataset.unet16.coupling_losses_0.4.json

@@ -0,0 +1,88 @@
+{
+  "run_name": "mapping_dataset.unet16.coupling_losses_0.4",
+
+  "data_dir_candidates": [
+    "/local/shared/data", // try cluster local node first
+    "/data/titane/user/nigirard/data", // Try cluster /data directory
+    "~/data", // In home directory (docker)
+    "/data" // In landsat's /data volume (docker)
+  ],
+  "data_root_partial_dirpath": "mapping_challenge_dataset",
+  "dataset_params": {
+    "small": false
+  },
+  "num_workers": 10,
+  "data_split_params": {
+    "seed": 0,  // Change this to change the random splitting of data in train/val/test
+    "train_fraction": 0.75,
+    "val_fraction": 0.25 // test_fraction is the rest
+  },
+  "data_aug_params": {
+    "enable": true,
+    "vflip": true,
+    "rotate": true,
+    "color_jitter": true,
+    "device": "cuda"
+  },
+
+  "device": "cuda",  // Only has effects when mode is val or test. When mode is train, always use CUDA
+  "use_amp": true,  // Automatic Mixed Precision switch
+
+  "backbone_params": {
+    "name": "unet",
+    "input_features": 3,
+    "features": 16
+  },
+
+  "compute_seg": true,
+  "compute_crossfield": true,
+
+  "seg_params": {
+    "compute_interior": true,
+    "compute_edge": true,
+    "compute_vertex": false
+  },
+
+  "loss_params": {
+    "multiloss": {
+      "normalization_params": {
+        "min_samples": 10,  // Per GPU
+        "max_samples": 1000  // Per GPU
+      },
+      "coefs": {
+        "seg_interior": 1,
+        "seg_edge": 1,
+        "seg_vertex": 0,
+        "crossfield_align": 1,
+        "crossfield_align90": 0.4,
+        "crossfield_smooth": 0.4,
+        "seg_interior_crossfield": 0.4,
+        "seg_edge_crossfield": 0.4,
+        "seg_edge_interior": 0.4
+      }
+    },
+    "seg_loss_params": {  // https://github.com/neptune-ai/open-solution-mapping-challenge/blob/master/neptune.yaml
+      "bce_coef": 1.0,
+      "dice_coef": 0.2,
+      "w0": 50,  // From original U-Net paper: distance weight to increase loss between objects
+      "sigma": 10  // From original U-Net paper: distance weight to increase loss between objects
+    }
+  },
+
+  "batch_size": 32,  // Batch size per GPU. The effective batch size is effective_batch_size=world_size*batch_size
+  "base_lr": 1e-4,  // Will be multiplied by the effective_batch_size=world_size*batch_size.
+  "max_lr": 1e-2,  // Maximum learning rate
+  "warmup_epochs": 1,  // Number of epochs for warmup (learning rate starts at lr*warmup_factor and gradually increases to lr)
+  "warmup_factor": 1e-3,
+  "weight_decay": 0,
+  "dropout_keep_prob": 1.0,  // Not used for now
+  "max_epoch": 25,
+  "log_steps": 50,
+  "checkpoint_epoch": 1,
+  "checkpoints_to_keep": 10,  // outputs
+  "logs_dirname": "logs",
+  "save_input_output": false,
+  "log_input_output": false,
+  "checkpoints_dirname": "checkpoints",
+  "eval_dirname": "eval"
+}