option.py

import argparse
from asyncio import FastChildWatcher
import tasks

import json


def modify_command_options(opts):

    if opts.dataset == 'voc':
        opts.num_classes = 21
    elif opts.dataset == 'ade':
        opts.num_classes = 151
    else:
        raise NotImplementedError(f"Unknown dataset: {opts.dataset}")


    if not opts.visualize:
        opts.sample_num = 0

    if opts.incremental_method is not None:
        if opts.incremental_method == 'FT':
            pass
        if opts.incremental_method == 'LWF':
            opts.loss_kd = 100
        if opts.incremental_method == 'ILT':
            opts.loss_kd = 100
            opts.loss_de = 100
        if opts.incremental_method == 'MiB':
            opts.unce = True
            opts.unkd = True
            opts.init_balanced = True
        if opts.incremental_method == 'PLOP':
            opts.pod = "local"
            opts.pod_factor = 0.01
            opts.pod_logits = True
            opts.pod_options = {"switch": {"after": {"extra_channels": "sum", "factor": 0.0005, "type": "local"}}}
            opts.pseudo = "entropy"
            opts.threshold = 0.001
            opts.classif_adaptive_factor = True
            opts.init_balanced = True

        if opts.incremental_method == 'RCIL':
            opts.pod = "local"
            opts.pod_factor = 0.01
            opts.pod_logits = True
            opts.pod_options = {"switch": {"after": {"extra_channels": "sum", "factor": 0.0005, "type": "local"}}}
            opts.loss_kd = 100
            opts.classif_adaptive_factor = True
            opts.init_balanced = True
            opts.unce = True
            opts.unkd = True

        if opts.incremental_method == 'OURS':
            opts.pod = "local"
            opts.pod_factor = 0.01
            opts.pod_logits = True
            opts.pod_options = {"switch": {"after": {"extra_channels": "sum", "factor": 0.0005, "type": "local"}}}
            opts.pseudo = "entropy"
            opts.threshold = 0.001
            opts.init_balanced = True
            opts.classif_adaptive_factor = True
            opts.out_dis = True

    
    opts.no_overlap = not opts.overlap
    opts.no_cross_val = not opts.cross_val

    return opts

def args_parser():

    parser = argparse.ArgumentParser()

    parser.add_argument("--data_root", type=str, default='./data/PascalVOC12', help="path to Dataset")
    parser.add_argument('--dataset', type=str, default='voc', choices=['voc', 'ade'], help="name of dataset")
    parser.add_argument("--task", type=str, default="4-4", choices=tasks.get_task_list(), help="Task to be executed (default: 4-4)")
    parser.add_argument('--incremental_method', type=str, default='OURS', choices=['FT', 'LWF', 'ILT', 'MiB', 'PLOP', 'RCIL', 'OURS'], help="name of method")
    parser.add_argument("--name",type=str,default='OURS',help="name of the experiment - to append to log directory (default: Experiment)")
    parser.add_argument('--class_ratio', type=float, default=0.5, help='ratio of classes (>1) for local clients') 
    parser.add_argument('--sample_ratio2', type=float, default=0.8, help='ratio of data for local clients (class>1)')
    parser.add_argument('--sample_ratio1', type=float, default=0.6, help='ratio of data for local clients (class=1)')
    parser.add_argument('--batch_size', type=int, default=24, help='size of mini-batch')  
    parser.add_argument('--epochs_local', type=int, default=6, help='local epochs of each global round')  
    parser.add_argument('--lr1', type=float, default=0.01, help='learning rate step=0')
    parser.add_argument('--lr2', type=float, default=0.001, help='learning rate step>0')
    parser.add_argument('--num_clients', type=int, default=10, help='initial number of clients') 
    parser.add_argument('--add_clients', type=int, default=4, help='the number of new add clients for each step') 
    parser.add_argument('--local_clients', type=int, default=4, help='the number of selected clients in each round')  
    parser.add_argument('--epochs_global', type=int, default=25, help='total number of global rounds') 
    parser.add_argument('--steps_global', type=int, default=5, help='the global rounds for each step (task)') 
    parser.add_argument("--seed", type=int, default=2023, help="random seed (default: 2023)")
    parser.add_argument("--use_entropy_detection", action="store_true", default=False)
    parser.add_argument("--entropy_threshold", type=float, default=0.6, help="threshold for entropy detection")
    

    # Performance Options
    parser.add_argument("--init_portion", type=float, default=0.2) 
    parser.add_argument("--max_portion", type=float, default=0.8)
    parser.add_argument("--portion_step", type=float, default=0.1) 
    parser.add_argument("--soft_factor", type=float, default=1.0)
    parser.add_argument('--proto_temperature', type=float, default=1.0)


    parser.add_argument("--local_rank", type=int, default=0)
    parser.add_argument("--num_workers", type=int, default=1, help='number of workers (default: 1)')


    # Datset Options
    parser.add_argument("--num_classes", type=int, default=None, help="num classes (default: None)")
    parser.add_argument(
        "--dont_predict_bg", action="store_true", default=False, help="Useful for cityscapes"
    )


    # Method Options
    # BE CAREFUL USING THIS, THEY WILL OVERRIDE ALL THE OTHER PARAMETERS.
    parser.add_argument("--strict_weights", action="store_false", default=True)
    parser.add_argument("--base_weights", action="store_true", default=False)

    # Train Options
    parser.add_argument(
        "--fix_bn",
        action='store_true',
        default=False,
        help='fix batch normalization during training (default: False)'
    )
    parser.add_argument("--crop_size", type=int, default=512, help="crop size (default: 513)")
    parser.add_argument("--mem_size", type=int, default=0, help="size of examplar memory")

    parser.add_argument(
        "--lr_old", type=float, default=None, help="learning rate for old classes weights."
    )
    parser.add_argument(
        "--momentum", type=float, default=0.9, help='momentum for SGD (default: 0.9)'
    )
    parser.add_argument(
        "--weight_decay", type=float, default=1e-4, help='weight decay (default: 1e-4)'
    )
    parser.add_argument(
        "--lr_policy",
        type=str,
        default='poly',
        choices=['poly', 'step'],
        help="lr schedule policy (default: poly)"
    )
    parser.add_argument(
        "--lr_decay_step", type=int, default=5000, help="decay step for stepLR (default: 5000)"
    )
    parser.add_argument(
        "--lr_decay_factor", type=float, default=0.1, help="decay factor for stepLR (default: 0.1)"
    )
    parser.add_argument(
        "--lr_power", type=float, default=0.9, help="power for polyLR (default: 0.9)"
    )
    parser.add_argument(
        "--bce", default=False, action='store_true', help="Whether to use BCE or not (default: no)"
    )


    # Validation Options
    parser.add_argument("--test_on_val", default=False, action="store_true")
    parser.add_argument(
        "--val_on_trainset",
        action='store_true',
        default=False,
        help="enable validation on train set (default: False)"
    )
    parser.add_argument(
        "--cross_val",
        action='store_true',
        default=False,
        help="If validate on training or on validation (default: Train)"
    )
    parser.add_argument(
        "--crop_val",
        action='store_false',
        default=True,
        help='do crop for validation (default: True)'
    )


    # Logging Options
    parser.add_argument(
        "--logdir", type=str, default='./logs', help="path to Log directory (default: ./logs)"
    )
    parser.add_argument(
        "--sample_num",
        type=int,
        default=0,
        help='number of samples for visualization (default: 0)'
    )
    parser.add_argument("--debug", action='store_true', default=False, help="verbose option")
    parser.add_argument(
        "--visualize",
        action='store_false',
        default=True,
        help="visualization on tensorboard (def: Yes)"
    )
    parser.add_argument(
        "--print_interval", type=int, default=10, help="print interval of loss (default: 10)"
    )
    parser.add_argument(
        "--val_interval", type=int, default=1, help="epoch interval for eval (default: 1)"
    )
    parser.add_argument(
        "--ckpt_interval", type=int, default=1, help="epoch interval for saving model (default: 1)"
    )


    # Model Options
    parser.add_argument(
        "--backbone",
        type=str,
        default='resnet101',
        choices=['resnet50', 'resnet101'],
        help='backbone for the body (def: resnet50)'
    )
    parser.add_argument(
        "--output_stride",
        type=int,
        default=16,
        choices=[8, 16],
        help='stride for the backbone (def: 16)'
    )
    parser.add_argument(
        "--no_pretrained",
        action='store_true',
        default=False,
        help='Wheather to use pretrained or not (def: True)'
    )
    parser.add_argument(
        "--norm_act",
        type=str,
        default="iabn_sync",
        choices=['iabn_sync', 'iabn', 'abn', 'std', 'iabn_sync_test'],
        help='Which BN to use (def: abn_sync'
    )

    parser.add_argument(
        "--fusion_mode",
        metavar="NAME",
        type=str,
        choices=["mean", "voting", "max"],
        default="mean",
        help="How to fuse the outputs. Options: 'mean', 'voting', 'max'"
    )
    parser.add_argument(
        "--pooling",
        type=int,
        default=32,
        help='pooling in ASPP for the validation phase (def: 32)'
    )


    # Test and Checkpoint options
    parser.add_argument(
        "--test",
        action='store_true',
        default=False,
        help="Whether to train or test only (def: train and test)"
    )
    parser.add_argument(
        "--ckpt",
        default=None,
        type=str,
        help="path to trained model. Leave it None if you want to retrain your model"
    )

    # Parameters for Knowledge Distillation of ILTSS (https://arxiv.org/abs/1907.13372)
    parser.add_argument(
        "--freeze",
        action='store_true',
        default=False,
        help="Use this to freeze the feature extractor in incremental steps"
    )
    parser.add_argument(
        "--loss_de",
        type=float,
        default=0.,  # Distillation on Encoder
        help="Set this hyperparameter to a value greater than "
        "0 to enable distillation on Encoder (L2)"
    )
    parser.add_argument(
        "--loss_kd",
        type=float,
        default=0.,  # Distillation on Output
        help="Set this hyperparameter to a value greater than "
        "0 to enable Knowlesge Distillation (Soft-CrossEntropy)"
    )


    # Parameters for EWC, RW, and SI (from Riemannian Walks https://arxiv.org/abs/1801.10112)
    parser.add_argument(
        "--regularizer",
        default=None,
        type=str,
        choices=['ewc', 'rw', 'pi'],
        help="regularizer you want to use. Default is None"
    )
    parser.add_argument(
        "--reg_importance",
        type=float,
        default=1.,
        help="set this par to a value greater than 0 to enable regularization"
    )
    parser.add_argument(
        "--reg_alpha",
        type=float,
        default=0.9,
        help="Hyperparameter for RW and EWC that controls the update of Fisher Matrix"
    )
    parser.add_argument(
        "--reg_no_normalize",
        action='store_true',
        default=False,
        help="If EWC, RW, PI must be normalized or not"
    )
    parser.add_argument(
        "--reg_iterations",
        type=int,
        default=10,
        help="If RW, the number of iterations after each the update of the score is done"
    )


    # Arguments for ICaRL (from https://arxiv.org/abs/1611.07725)
    parser.add_argument(
        "--icarl", default=False, action='store_true', help="If enable ICaRL or not (def is not)"
    )
    parser.add_argument(
        "--icarl_importance",
        type=float,
        default=1.,
        help="the regularization importance in ICaRL (def is 1.)"
    )
    parser.add_argument(
        "--icarl_disjoint",
        action='store_true',
        default=False,
        help="Which version of icarl is to use (def: combined)"
    )
    parser.add_argument(
        "--icarl_bkg",
        action='store_true',
        default=False,
        help="If use background from GT (def: No)"
    )


    # METHODS
    parser.add_argument(
        "--init_balanced",
        default=False,
        action='store_true',
        help="Enable Background-based initialization for new classes"
    )
    parser.add_argument(
        "--unkd",
        default=False,
        action='store_true',
        help="Enable Unbiased Knowledge Distillation instead of Knowledge Distillation"
    )
    parser.add_argument(
        "--myselfkd",
        default=False,
        action='store_true',
        help="Enable Unbiased Knowledge Distillation instead of Knowledge Distillation"
    )
    parser.add_argument(
        "--alpha",
        default=1.,
        type=float,
        help="The parameter to hard-ify the soft-labels. Def is 1."
    )
    parser.add_argument(
        "--unce",
        default=False,
        action='store_true',
        help="Enable Unbiased Cross Entropy instead of CrossEntropy"
    )


    # Incremental parameters
    parser.add_argument(
        "--step",
        type=int,
        nargs="+",
        default=[0],
        help="The incremental step in execution (default: 0)"
    )
    parser.add_argument(
        "--no_mask",
        action='store_true',
        default=False,
        help="Use this to not mask the old classes in new training set"
    )
    parser.add_argument(
        "--data_masking",
        type=str,
        default="current",
        choices=["current", "current+old", "all", "new"]
    )
    parser.add_argument(
        "--overlap",
        action='store_true',
        default=False,
        help="Use this to not use the new classes in the old training set"
    )
    parser.add_argument(
        "--step_ckpt",
        default=None,
        type=str,
        help="path to trained model at previous step. Leave it None if you want to use def path"
    )
    parser.add_argument('--opt_level', type=str, choices=['O0', 'O1', 'O2', 'O3'], default='O1')


    # Pseudo-labeling
    parser.add_argument(
        "--pseudo",
        type=str,
        default=None,
        help="Pseudo-labeling method." +
        ", ".join(["naive", "confidence", "threshold_5", "threshold_8", "median", "entropy"])
    )
    parser.add_argument("--threshold", type=float, default=0.9)
    parser.add_argument("--step_threshold", type=float, default=None)
    parser.add_argument(
        "--ce_on_pseudo",
        default=False,
        action="store_true",
        help="Pseudo Labels are trained w/ CE, default criterion for others"
    )
    parser.add_argument("--pseudo_nb_bins", default=None, type=int)
    parser.add_argument("--classif_adaptive_factor", default=False, action="store_true")
    parser.add_argument("--classif_adaptive_min_factor", default=0.0, type=float)
    parser.add_argument("--pseudo_soft", default=None, type=str, choices=["soft_certain", "soft_uncertain"])
    parser.add_argument("--pseudo_soft_factor", default=1.0, type=float)
    parser.add_argument("--pseudo_ablation", default=None, choices=["corrected_errors", "removed_errors"])


    parser.add_argument("--kd_new", default=False, action="store_true", help="Apply KD only on new")

    parser.add_argument(
        "--checkpoint", type=str, default="./checkpoints"
    )
    parser.add_argument(
        "--pod",
        default=None,
        type=str,
        choices=[
            "spatial", "local", "global"
        ]
    )
    parser.add_argument("--pod_factor", default=5., type=float)
    parser.add_argument("--soft_param", default=1, type=float)
    parser.add_argument("--regular_param", default=1., type=float)
    parser.add_argument("--pod_options", default=None, type=json.loads)
    parser.add_argument("--pod_prepro", default="pow", type=str)
    parser.add_argument("--no_pod_schedule", default=False, action="store_true")
    parser.add_argument(
        "--pod_apply", default="all", type=str, choices=["all", "backbone", "deeplab"]
    )
    parser.add_argument("--pod_deeplab_mask", default=False, action="store_true")
    parser.add_argument(
        "--pod_deeplab_mask_factor", default=None, type=float, help="By default as the POD factor"
    )
    parser.add_argument("--deeplab_mask_downscale", action="store_true", default=False)
    parser.add_argument("--pod_interpolate_last", default=False, action="store_true")
    parser.add_argument(
        "--pod_logits", default=False, action="store_true", help="Also apply POD to logits."
    )
    parser.add_argument(
        "--out_dis", default=False, action="store_true", help="apply output distillation."
    )
    parser.add_argument(
        "--pseudo_proto", default=False, action="store_true", help="apply output distillation."
    )
    parser.add_argument("--feat_dim", type=float, default=2048,
                        help="Dimensionality of the features space (default: 2048 as in Resnet-101)")
    parser.add_argument(
        "--pod_large_logits", default=False, action="store_true", help="Also apply POD to large logits."
    )
    parser.add_argument("--spp_scales", default=[1, 2, 4], type=int, nargs="+")
    parser.add_argument("--date", default="", type=str)
    parser.add_argument("--nb_background_modes", default=1, type=int)
    parser.add_argument(
        "--init_multimodal",
        default=None,
        type=str,
        choices=["max", "softmax", "max_init", "softmax_init", "softmax_remove", "max_remove"]
    )
    parser.add_argument("--multimodal_fusion", default="sum", type=str)
    parser.add_argument("--align_weight", default=None, choices=["old", "background", "all"])
    parser.add_argument(
        "--align_weight_frequency", default="never", choices=["never", "epoch", "task"]
    )
    parser.add_argument("--cosine", default=False, action="store_true")
    parser.add_argument("--nca", default=False, action="store_true")
    parser.add_argument("--nca_margin", default=0., type=float)
    parser.add_argument("--kd_mask", default=None, choices=["oldbackground", "new"])
    parser.add_argument("--kd_mask_adaptative_factor", default=False, action="store_true")
    parser.add_argument(
        "--disable_background",
        action="store_true",
        help="Remove the fake background, only for Cityscapes. DEPRECATED TO REMOVE"
    )
    parser.add_argument("--ignore_test_bg", action="store_true", default=False)
    parser.add_argument(
        "--entropy_min",
        default=0.,
        type=float,
        help="Factor for the entropy minimization (cf advent)"
    )
    parser.add_argument("--entropy_min_mean_pixels", default=False, action="store_true", help="")
    parser.add_argument("--kd_scheduling", default=False, action="store_true")
    parser.add_argument("--sample_weights_new", default=None, type=float)
    parser.add_argument("--temperature", default=1.0, type=float)
    parser.add_argument("--temperature_semiold", default=1.0, type=float)
    parser.add_argument("--temperature_apply", default=None, choices=["all", "new", "old"])
    parser.add_argument("--code_directory", default=".")
    parser.add_argument("--kd_bce_sig", action="store_true", default=False)
    parser.add_argument("--kd_bce_sig_shape", choices=["trim", "sum"], default="trim")
    parser.add_argument("--exkd_gt", action="store_true", default=False)
    parser.add_argument("--exkd_sum", action="store_true", default=False)
    parser.add_argument("--focal_loss", action="store_true", default=False)
    parser.add_argument("--focal_loss_new", action="store_true", default=False)
    parser.add_argument("--focal_loss_gamma", default=2, type=int)
    parser.add_argument("--ce_on_new", default=False, action="store_true")

    args = parser.parse_args()
    return args