options.py

# Copyright Niantic 2019. Patent Pending. All rights reserved.
#
# This software is licensed under the terms of the Monodepth2 licence
# which allows for non-commercial use only, the full terms of which are made
# available in the LICENSE file.

from __future__ import absolute_import, division, print_function

import os
import configargparse
from typing import List

file_dir = os.path.dirname(__file__)  # the directory that options.py resides in


class MonodepthOptions:
    def __init__(self):
        self.parser = configargparse.ArgumentParser()

        self.parser.add_argument('--config', is_config_file=True,
                                 help='config file path')

        # PATHS
        self.parser.add_argument("--data_path",
                                 type=str,
                                 help="path to the training data",
                                 default=os.path.join(file_dir, "kitti_data"))
        self.parser.add_argument("--log_dir",
                                 type=str,
                                 help="log directory",
                                 default='./logs')

        # TRAINING options
        self.parser.add_argument("--model_name",
                                 type=str,
                                 help="the name of the folder to save the model in",
                                 default="mdp")
        self.parser.add_argument("--split",
                                 type=str,
                                 help="which training split to use",
                                 choices=["eigen_zhou", "eigen_full", "odom", "benchmark"],
                                 default="eigen_zhou")
        self.parser.add_argument("--num_layers",
                                 type=int,
                                 help="number of resnet layers",
                                 default=34,
                                 choices=[18, 34, 50, 101, 152])
        self.parser.add_argument("--dataset",
                                 type=str,
                                 help="dataset to train on",
                                 default="kitti"
                                 )
        self.parser.add_argument("--png",
                                 help="if set, trains from raw KITTI png files (instead of jpgs)",
                                 action="store_true")
        self.parser.add_argument("--height",
                                 type=int,
                                 help="input image height",
                                 default=384)
        self.parser.add_argument("--width",
                                 type=int,
                                 help="input image width",
                                 default=640)
        self.parser.add_argument("--height_crop",
                                 type=int,
                                 help="height before crop",
                                 default=450)
        self.parser.add_argument("--width_crop",
                                 type=int,
                                 help="width before crop",
                                 default=800)
        self.parser.add_argument("--height_ori",
                                 type=int,
                                 help="original input image height",
                                 default=1216)
        self.parser.add_argument("--width_ori",
                                 type=int,
                                 help="original input image width",
                                 default=1936)
        self.parser.add_argument("--disparity_smoothness",
                                 type=float,
                                 help="disparity smoothness weight",
                                 default=1e-3)
        self.parser.add_argument("--scales",
                                 nargs="+",
                                 type=int,
                                 help="scales used in the loss",
                                 default=[0, 1, 2, 3])
        self.parser.add_argument("--min_depth",
                                 type=float,
                                 help="minimum depth",
                                 default=0.1)
        self.parser.add_argument("--max_depth",
                                 type=float,
                                 help="maximum depth",
                                 default=100.0)
        self.parser.add_argument("--use_stereo",
                                 help="if set, uses stereo pair for training",
                                 action="store_true")
        self.parser.add_argument("--frame_ids",
                                 nargs="+",
                                 type=int,
                                 help="frames to load, currently only support for 3 frames",
                                 default=[0, -1, 1])
        self.parser.add_argument("--eval_only",
                                 help="if set, only evaluation",
                                 action="store_true")
        self.parser.add_argument("--use_fix_mask",
                                 help="if set, use self-occlusion mask (only for DDAD)",
                                 action="store_true")
        self.parser.add_argument("--spatial",
                                 help="if set, use spatial photometric loss",
                                 action="store_true")
        self.parser.add_argument("--joint_pose",
                                 help="if set, use joint pose estimation",
                                 action="store_true")
        self.parser.add_argument("--no_crop",
                                 help="if set, no crop",
                                 action="store_true")
        self.parser.add_argument("--model_type",
                                 type=str,
                                 default="unet")
        self.parser.add_argument("--use_sfm_spatial",
                                 help="if set, use sfm pseudo label",
                                 action="store_true")
        self.parser.add_argument("--thr_dis",
                                 type=float,
                                 help="epipolar geometry threshold",
                                 default=1.0)
        self.parser.add_argument("--match_spatial_weight",
                                 type=float,
                                 help="sfm pretraining loss weight",
                                 default=0.1)
        self.parser.add_argument("--spatial_weight",
                                 type=float,
                                 help="spatial photometric loss weight",
                                 default=0.1)
        self.parser.add_argument("--skip",
                                 help="if set, use skip connection in CVT",
                                 action="store_true")
        self.parser.add_argument("--focal",
                                 help="if set, use sfm pseudo label",
                                 action="store_true")
        self.parser.add_argument("--focal_scale",
                                 type=float,
                                 help="the global focal length to normalize depth",
                                 default=500)

        # OPTIMIZATION options
        self.parser.add_argument("--batch_size",
                                 type=int,
                                 help="batch size",
                                 default=12)
        self.parser.add_argument("--learning_rate_pose",
                                 type=float,
                                 help="learning rate of pose net",
                                 default=1e-4)
        self.parser.add_argument("--learning_rate_encoder",
                                 type=float,
                                 help="learning rate of dino encoder",
                                 default=5e-6)
        self.parser.add_argument("--learning_rate_decoder",
                                 type=float,
                                 help="learning rate of DPT decoder",
                                 default=5e-5)
        self.parser.add_argument("--num_epochs",
                                 type=int,
                                 help="number of epochs",
                                 default=20)
        self.parser.add_argument("--scheduler_step_size",
                                 type=int,
                                 help="step size of the scheduler",
                                 default=15)

        # ABLATION options
        self.parser.add_argument("--v1_multiscale",
                                 help="if set, uses monodepth v1 multiscale",
                                 action="store_true")
        self.parser.add_argument("--avg_reprojection",
                                 help="if set, uses average reprojection loss",
                                 action="store_true")
        self.parser.add_argument("--disable_automasking",
                                 help="if set, doesn't do auto-masking",
                                 action="store_true")
        self.parser.add_argument("--predictive_mask",
                                 help="if set, uses a predictive masking scheme as in Zhou et al",
                                 action="store_true")
        self.parser.add_argument("--no_ssim",
                                 help="if set, disables ssim in the loss",
                                 action="store_true")
        self.parser.add_argument("--weights_init",
                                 type=str,
                                 help="pretrained or scratch",
                                 default="pretrained",
                                 choices=["pretrained", "scratch"])
        self.parser.add_argument("--pose_model_input",
                                 type=str,
                                 help="how many images the pose network gets",
                                 default="pairs",
                                 choices=["pairs", "all"])
        self.parser.add_argument("--pose_model_type",
                                 type=str,
                                 help="normal or shared",
                                 default="separate_resnet")


        # SYSTEM options
        self.parser.add_argument("--no_cuda",
                                 help="if set disables CUDA",
                                 action="store_true")
        self.parser.add_argument("--num_workers",
                                 type=int,
                                 help="number of dataloader workers",
                                 default=12)

        # LOADING options
        self.parser.add_argument("--load_weights_folder",
                                 type=str,
                                 help="name of model to load")
        self.parser.add_argument("--models_to_load",
                                 nargs="+",
                                 type=str,
                                 help="models to load",
                                 default=["encoder", "depth", "pose_encoder", "pose"])

        # LOGGING options
        self.parser.add_argument("--log_frequency",
                                 type=int,
                                 help="number of batches between each tensorboard log",
                                 default=25)
        self.parser.add_argument("--save_frequency",
                                 type=int,
                                 help="number of epochs between each save",
                                 default=1)
        self.parser.add_argument("--eval_frequency",
                                 type=int,
                                 help="number of epochs between each save",
                                 default=1000)


        # EVALUATION options
        self.parser.add_argument("--eval_stereo",
                                 help="if set evaluates in stereo mode",
                                 action="store_true")
        self.parser.add_argument("--eval_mono",
                                 help="if set evaluates in mono mode",
                                 action="store_true")
        self.parser.add_argument("--disable_median_scaling",
                                 help="if set disables median scaling in evaluation",
                                 action="store_true")
        self.parser.add_argument("--pred_depth_scale_factor",
                                 help="if set multiplies predictions by this number",
                                 type=float,
                                 default=1)
        self.parser.add_argument("--ext_disp_to_eval",
                                 type=str,
                                 help="optional path to a .npy disparities file to evaluate")
        self.parser.add_argument("--eval_split",
                                 type=str,
                                 default="eigen",
                                 choices=[
                                    "eigen", "eigen_benchmark", "benchmark", "odom_9", "odom_10"],
                                 help="which split to run eval on")
        self.parser.add_argument("--save_pred_disps",
                                 help="if set saves predicted disparities",
                                 action="store_true")
        self.parser.add_argument("--no_eval",
                                 help="if set disables evaluation",
                                 action="store_true")
        self.parser.add_argument("--eval_eigen_to_benchmark",
                                 help="if set assume we are loading eigen results from npy but "
                                      "we want to evaluate using the new benchmark.",
                                 action="store_true")
        self.parser.add_argument("--eval_out_dir",
                                 help="if set will output the disparities to this folder",
                                 type=str)
        self.parser.add_argument("--post_process",
                                 help="if set will perform the flipping post processing "
                                      "from the original monodepth paper",
                                 action="store_true")


        # CORRUPTION options
        self.parser.add_argument("--corruption_root",
                                 default="./data/robodrive",
                                 help="corruption root path",
                                 type=str)
        self.parser.add_argument("--corruption",
                                 default="brightness",
                                 help="corruption type name",
                                 type=str)
        self.parser.add_argument("--phase2",
                                 action="store_true")

        self.parser.add_argument("--local-rank", default=0,type=int)

        self.parser.add_argument("--encoder", default='vitb',type=str)
        
        # denoise
        self.parser.add_argument("--denoise",
                                 default=["universal_denoise","equalize"],
                                 help="denoise",
                                 type=str,
                                 nargs="+")
        
        
    def parse(self):
        self.options = self.parser.parse_args()
        return self.options