def build_num_workers_cfg(node, key='num_workers'):
if key not in node:
node[key] = CN()
node[key].train = 8
node[key].val = 2
node[key].test = 2
return node[key]
def gen_default_cfg() -> CfgNode:
cfg = CfgNode()
cfg.KEY1 = "default"
cfg.KEY2 = "default"
cfg.EXPRESSION = [3.0]
return cfg
def create_conv_layers(node, key='layer'):
if key not in node:
node[key] = CN()
node[key].num_layers = 5
node[key].num_filters = 2048
node[key].stride = 1
return node[key]
def create_mlp_config(node, key='mlp'):
if key not in node:
node[key] = CN()
node[key].layers = (1024, 1024)
node[key].activ_type = 'relu'
node[key].lrelu_slope = 0.2
node[key].norm_type = 'none'
node[key].num_groups = 32
node[key].dropout = 0.0
node[key].init_type = 'xavier'
node[key].gain = 0.01
node[key].bias_init = 0.0
return node[key]
def get_config_from_args(args=None):
"""
Parses command line arguments and merges them with the defaults
from the config file.
Prepares experiment directories.
Args:
args: args from a different argument parser than the default one.
"""
# load the default base
with open(os.path.join(get_project_root(), 'defaults', 'darts_defaults.yaml')) as f:
config = CfgNode.load_cfg(f)
if not args:
args = parse_args()
logger.info("Command line args: {}".format(args))
config.eval_only = args.eval_only
config.resume = args.resume
# load config file
config.merge_from_file(args.config_file)
config.merge_from_list(args.opts)
# prepare the output directories
config.save = '{}/{}/{}/{}'.format(config.out_dir, config.dataset, config.optimizer, config.seed)
config.data = "{}/data".format(get_project_root())
create_exp_dir(config.save)
create_exp_dir(config.save + "/search") # required for the checkpoints
create_exp_dir(config.save + "/eval")
return config
def setup(args):
utils.init_seeds(20)
cfg = config.clone()
if len(args.model_config) > 0:
cfg.merge_from_file(args.model_config)
opt = CfgNode(args.__dict__)
cfg.merge_from_other_cfg(opt)
device = torch.device(cfg.DEVICE) if torch.cuda.is_available() else torch.device('cpu')
cfg.update({'DEVICE': device})
model = model_factory.create_model(cfg)
dataloader = create_dataloader(cfg.DATASET.PATH, cfg,
TrainAugmentation(cfg.INPUT_SIZE[0], mean=cfg.DATASET.MEAN),
is_training=True)[0]
test_dataloader = create_dataloader(cfg.DATASET.PATH, cfg,
TestTransform(cfg.INPUT_SIZE[0], mean=cfg.DATASET.MEAN),
is_training=True, split='test')[0]
model.train()
model.to(cfg.DEVICE)
nb = len(dataloader)
max_step_burn_in = max(3 * nb, 1e3) # burn-in iterations, max(3 epochs, 1k iterations)
# solver = Solver(model, cfg, max_steps_burn_in=max_step_burn_in, apex=amp)
solver = Solver(model, cfg)
rtm3d_loss = RTM3DLoss(cfg)
return model, (dataloader, test_dataloader), solver, rtm3d_loss, cfg
def get_cfg(cfg_filename: str, allow_unsafe=True) -> CfgNode:
"""
Get a copy of the default config.
Returns:
a mydl CfgNode instance.
"""
loaded_cfg = _CfgNode.load_yaml_with_base(cfg_filename,
allow_unsafe=allow_unsafe)
# from .defaults import _C
meta_arch = loaded_cfg['MODEL']['META_ARCHITECTURE']
if meta_arch == 'ProteinResnet':
# protein.py needs to import CfgNode
from .protein import _C
# elif meta_arch == 'some meta arch' :
# from .xxx import _C
else:
# defaults.py needs to import CfgNode
from .defaults import _C
return _C.clone()
def merge_from_file(self,
cfg_filename: str,
allow_unsafe: bool = True) -> None:
loaded_cfg = _CfgNode.load_yaml_with_base(cfg_filename,
allow_unsafe=allow_unsafe)
loaded_cfg = type(self)(loaded_cfg)
# defaults.py needs to import CfgNode
self.merge_from_other_cfg(loaded_cfg)
def __init__(self, cfg: CfgNode, dataset_name: str, trainer: DefaultTrainer, steps: int=10, ndata: int=5):
super().__init__()
self.cfg = cfg.clone()
self.cfg.DATASETS.TRAIN = (dataset_name, )
self._loader = iter(build_detection_train_loader(self.cfg))
self.trainer = trainer
self.steps = steps
self.ndata = ndata
self.loss_dict = {}
self.data_time = 0
def merge_from_file(self,
cfg_filename: str,
allow_unsafe: bool = True) -> None:
assert PathManager.isfile(
cfg_filename), f"Config file '{cfg_filename}' does not exist!"
loaded_cfg = _CfgNode.load_yaml_with_base(cfg_filename,
allow_unsafe=allow_unsafe)
loaded_cfg = type(self)(loaded_cfg)
self.merge_from_other_cfg(loaded_cfg)
def configure(args):
utils.init_seeds(20)
cfg = config.clone()
if len(args.model_config) > 0:
cfg.merge_from_file(args.model_config)
opt = CfgNode(args.__dict__)
cfg.merge_from_other_cfg(opt)
if cfg.dist_url == "env://" and cfg.world_size == -1:
cfg.world_size = int(os.environ["WORLD_SIZE"])
cfg.distributed = cfg.world_size > 1 or cfg.multiprocessing_distributed
cfg.ngpus_per_node = torch.cuda.device_count()
return cfg
def create_subsample_layer(node,
num_layers=3,
key='layer',
kernel_size=3,
stride=2):
if key not in node:
node[key] = CN()
node[key].num_filters = (512, ) * num_layers
node[key].norm_type = 'bn'
node[key].activ_type = 'relu'
node[key].dim = 2
node[key].kernel_sizes = [kernel_size] * len(node[key].num_filters)
node[key].strides = [stride] * len(node[key].num_filters)
node[key].padding = 1
return node[key]
def _create_gradient_clipper(cfg: CfgNode) -> _GradientClipper:
cfg = cfg.clone()
def clip_grad_norm(p: _GradientClipperInput):
torch.nn.utils.clip_grad_norm_(p, cfg.CLIP_VALUE, cfg.NORM_TYPE)
def clip_grad_value(p: _GradientClipperInput):
torch.nn.utils.clip_grad_value_(p, cfg.CLIP_VALUE)
_GRADIENT_CLIP_TYPE_TO_CLIPPER = {
GradientClipType.VALUE: clip_grad_value,
GradientClipType.NORM: clip_grad_norm,
}
return _GRADIENT_CLIP_TYPE_TO_CLIPPER[GradientClipType(cfg.CLIP_TYPE)]
def add_custom_config(_C):
# Knowledge distillation
_C.KD = CfgNode()
# If True enable KD, else skip KD.
_C.KD.ENABLE = False
# Teacher's config
_C.KD.CONFIG = ""
# Alpha
_C.KD.ALPHA = 0.95
# Temperature
_C.KD.TEMPERATURE = 6
# Teacher's config
_C.KD.CONFIG = "configs/Kinetics/SLOWFAST_8x8_R50.yaml"
# Path to the checkpoint to load the initial weight.
_C.KD.CHECKPOINT_FILE_PATH = ""
# Checkpoint types include `caffe2` or `pytorch`.
_C.KD.CHECKPOINT_TYPE = "pytorch"
_C.KD.TEACHER_TRANS_FUNC = 'bottleneck_transform'
# TSM
_C.TSM = CfgNode()
# n_div for TSM
_C.TSM.N_DIV = [[8, 8], [8, 8], [8, 8], [8, 8]]
# fusion n_div
_C.TSM.FUSION_N_DIV = [8, 8, 8, 8]
_C.TEST.CLASS_LIST = 'filenames/kinetics-40'
def merge_from_file(
self, cfg_filename: str, allow_unsafe: bool = True
) -> None:
loaded_cfg = _CfgNode.load_yaml_with_base(
cfg_filename, allow_unsafe=allow_unsafe
)
loaded_cfg = type(self)(loaded_cfg)
# defaults.py needs to import CfgNode
from .defaults import _CC as _C
latest_ver = _C.VERSION
assert (
latest_ver == self.VERSION
), "CfgNode.merge_from_file is only allowed on a config of latest version!"
logger = logging.getLogger(__name__)
loaded_ver = loaded_cfg.get("VERSION", None)
if loaded_ver is None:
from .compat import guess_version
loaded_ver = guess_version(loaded_cfg, cfg_filename)
assert (
loaded_ver <= self.VERSION
), "Cannot merge a v{} config into a v{} config.".format(
loaded_ver, self.VERSION
)
if loaded_ver == self.VERSION:
self.merge_from_other_cfg(loaded_cfg)
else:
# compat.py needs to import CfgNode
from .compat import downgrade_config, upgrade_config
logger.warning(
"Loading an old v{} config file '{}' by automatically upgrading to v{}. "
"See docs/CHANGELOG.md for instructions to update your files.".format(
loaded_ver, cfg_filename, self.VERSION
)
)
# To convert, first obtain a full config at an old version
old_self = downgrade_config(self, to_version=loaded_ver)
old_self.merge_from_other_cfg(loaded_cfg)
new_config = upgrade_config(old_self)
self.clear()
self.update(new_config)
from fvcore.common.config import CfgNode as CN
_C = CN()
_C.MODEL = CN()
_C.MODEL.RESNETS = CN()
_C.MODEL.RESNETS.DEPTH = 50
_C.MODEL.RESNETS.OUT_FEATURES = [
"res4"
] # res4 for C4 backbone, res2..5 for FPN backbone
# Number of groups to use; 1 ==> ResNet; > 1 ==> ResNeXt
_C.MODEL.RESNETS.NUM_GROUPS = 1
# Options: FrozenBN, GN, "SyncBN", "BN"
_C.MODEL.RESNETS.NORM = "BN"
# Baseline width of each group.
# Scaling this parameters will scale the width of all bottleneck layers.
_C.MODEL.RESNETS.WIDTH_PER_GROUP = 64
# Place the stride 2 conv on the 1x1 filter
# Use True only for the original MSRA ResNet; use False for C2 and Torch models
_C.MODEL.RESNETS.STRIDE_IN_1X1 = True
# Apply dilation in stage "res5"
_C.MODEL.RESNETS.RES5_DILATION = 1
# Output width of res2. Scaling this parameters will scale the width of all 1x1 convs in ResNet
# For R18 and R34, this needs to be set to 64
_C.MODEL.RESNETS.RES2_OUT_CHANNELS = 256
_C.MODEL.RESNETS.STEM_OUT_CHANNELS = 64
#!/usr/bin/env python3 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. """Configs.""" from fvcore.common.config import CfgNode # ----------------------------------------------------------------------------- # Config definition # ----------------------------------------------------------------------------- _C = CfgNode() # ---------------------------------------------------------------------------- # # Batch norm options # ---------------------------------------------------------------------------- # _C.BN = CfgNode() # BN epsilon. _C.BN.EPSILON = 1e-5 # BN momentum. _C.BN.MOMENTUM = 0.1 # Precise BN stats. _C.BN.USE_PRECISE_STATS = False # Number of samples use to compute precise bn. _C.BN.NUM_BATCHES_PRECISE = 200 # Weight decay value that applies on BN. _C.BN.WEIGHT_DECAY = 0.0
from copy import deepcopy # from yacs.config import CfgNode as CN from fvcore.common.config import CfgNode as CN _C = CN() _C.stages_to_penalize = [-1] _C.stages_to_regularize = [-1] _C.body_joints_2d = CN() _C.body_joints_2d.type = 'keypoints' _C.body_joints_2d.robustifier = 'none' _C.body_joints_2d.norm_type = 'l1' _C.body_joints_2d.rho = 100.0 _C.body_joints_2d.beta = 5.0 / 100 * 2 _C.body_joints_2d.size_average = True _C.body_joints_2d.weight = 1.0 _C.body_joints_2d.enable = 0 _C.hand_joints_2d = CN() _C.hand_joints_2d.type = 'keypoints' _C.hand_joints_2d.norm_type = 'l1' _C.hand_joints_2d.robustifier = 'none' _C.hand_joints_2d.rho = 100.0 _C.hand_joints_2d.beta = 5.0 / 100 * 2 _C.hand_joints_2d.size_average = True _C.hand_joints_2d.weight = 1.0 _C.hand_joints_2d.enable = 0 _C.face_joints_2d = CN() _C.face_joints_2d.type = 'keypoints'
#!/usr/bin/env python3 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. """Configs.""" from fvcore.common.config import CfgNode from . import custom_config # ----------------------------------------------------------------------------- # Config definition # ----------------------------------------------------------------------------- _C = CfgNode() # ---------------------------------------------------------------------------- # # Batch norm options # ---------------------------------------------------------------------------- # _C.BN = CfgNode() # BN epsilon. _C.BN.EPSILON = 1e-5 # BN momentum. _C.BN.MOMENTUM = 0.1 # Precise BN stats. _C.BN.USE_PRECISE_STATS = False # Number of samples use to compute precise bn. _C.BN.NUM_BATCHES_PRECISE = 200 # Weight decay value that applies on BN. _C.BN.WEIGHT_DECAY = 0.0
def __init__(self,
config_file: Optional[str] = None,
override_list: List[Any] = []):
_C = CN()
# Random seed for NumPy and PyTorch, important for reproducibility.
_C.RANDOM_SEED = 0
# Train with Automatic Mixed Precision (native PyTorch).
_C.AMP = True
# Set CUDNN deterministic flag (torch.backends.cudnn.deterministic).
# Setting this will ensure exact results on every run at the cost of
# little slowdown. Good for debugging.
_C.CUDNN_DETERMINISTIC = False
# Set CUDNN benchmark flag (torch.backends.cudnn.benchmark). Enables
# CUDNN to select fastest implementation for operations based on GPU.
# May change results (in decimals) on different hardware, but faster
# to train. Turn off while debugging.
_C.CUDNN_BENCHMARK = True
# ---------------------------------------------------------------------
# Data paths and parameters related to dataloading.
# ---------------------------------------------------------------------
_C.DATA = CN()
# Path to the dataset root, which structure as per README. Path is
# assumed to be relative to project root.
_C.DATA.ROOT = "datasets/coco"
# Path to .model file generated by ``sentencepiece``.
_C.DATA.TOKENIZER_MODEL = "datasets/vocab/coco_10k.model"
# Handy config params for vocab size and indices of special tokens.
# While these can be picked up from the tokenizer, having these in
# the config makes it easy to create a model without instantiating too
# many tokenizer instances (especially when not needed, e.g. model zoo).
# These must match according to what's present in ``TOKENIZER_VOCAB``
# and ``TOKENIZER_MODEL`` above.
_C.DATA.VOCAB_SIZE = 10000
# Index of out-of-vocabulary (and padding) token.
_C.DATA.UNK_INDEX = 0
# Index of the start-of-sentence [SOS] token.
_C.DATA.SOS_INDEX = 1
# Index of the end-of-sentence [EOS] token.
_C.DATA.EOS_INDEX = 2
# Index of the word masking token. While not used for captioning, having
# this extra token makes it possible to train an MLM model without
# re-creating a new vocab mapping.
_C.DATA.MASK_INDEX = 3
# Size of the image (square) to crop from original input image.
_C.DATA.IMAGE_CROP_SIZE = 224
# Maximum length of input caption (number of tokens).
# Longer captions will be truncated up to this length.
_C.DATA.MAX_CAPTION_LENGTH = 30
# COCO Captions has five captions per image. If ``True``, training will
# use one random caption per image (data efficiency ablations).
_C.DATA.USE_SINGLE_CAPTION = False
# Percentage of dataset to use for training (data efficiency ablations).
_C.DATA.USE_PERCENTAGE = 100.0
# List of image transforms (pre-processing and data augmentation) to be
# applied sequentially (always or randomly) during training and
# validation. Refer ``virtex/facetories.py`` for all possible transforms.
_C.DATA.IMAGE_TRANSFORM_TRAIN = [
"random_resized_crop",
"horizontal_flip",
"color_jitter",
"normalize",
]
_C.DATA.IMAGE_TRANSFORM_VAL = [
"smallest_resize",
"center_crop",
"normalize",
]
# Hyper-parameters for masked LM pretraining task. These are only used
# when ``MODEL.NAME`` is "masked_lm".
_C.DATA.MASKED_LM = CN()
# Fraction of tokens to choose for masking, this must be less than 1.
_C.DATA.MASKED_LM.MASK_PROPORTION = 0.15
# Probability to replace chosen tokens with [MASK] token.
_C.DATA.MASKED_LM.MASK_PROBABILITY = 0.85
# Probability to replace chosen tokens with a random token.
_C.DATA.MASKED_LM.REPLACE_PROBABILITY = 0.10
# ---------------------------------------------------------------------
# Model architecture: visual backbone and textual head.
# ---------------------------------------------------------------------
_C.MODEL = CN()
# Name of model, based on pretraining task.
# Possible choices: {"token_classification", "multilabel_classification",
# "captioning", "bicaptioning", "masked_lm", "virtex"}
_C.MODEL.NAME = "virtex"
_C.MODEL.VISUAL = CN()
# Name of visual backbone. Possible choices: {"blind", "torchvision"}
# Models from torchvision can be specified as shown below.
_C.MODEL.VISUAL.NAME = "torchvision::resnet50"
# Number of channels in pooled spatial features of visual backbone.
_C.MODEL.VISUAL.FEATURE_SIZE = 2048
# Whether to load ImageNet pretrained weights into visual backbone.
_C.MODEL.VISUAL.PRETRAINED = False
# Whether to keep visual backbone frozen and train only textual head.
_C.MODEL.VISUAL.FROZEN = False
_C.MODEL.TEXTUAL = CN()
# Name of textual head. Set to "none" for MODEL.NAME = "*_classification".
# Possible choices: {"transformer_postnorm", "transformer_prenorm"}.
# Architectural hyper-parameters are specified as shown above.
_C.MODEL.TEXTUAL.NAME = "transformer_postnorm::L1_H2048_A32_F8192"
# L = Number of layers in the transformer.
# H = Hidden size of the transformer (embeddings, attention features).
# A = Number of attention heads in the transformer.
# F = Size of feedforward layers in the transformer.
# Typically, we have (A = H / 64) and (F = 4 * H).
# Dropout probability for embedding, hidden features in textual head.
_C.MODEL.TEXTUAL.DROPOUT = 0.1
# ---------------------------------------------------------------------
# Optimization hyper-parameters, default values are for pretraining
# our best model on bicaptioning task (COCO Captions).
# ---------------------------------------------------------------------
_C.OPTIM = CN()
# Name of optimizer to use. Supported values: {"sgd", "adamw"}.
# AdamW uses default (beta1, beta2) values from PyTorch.
_C.OPTIM.OPTIMIZER_NAME = "sgd"
# Momentum co-efficient for SGD. Ignored for AdamW.
_C.OPTIM.SGD_MOMENTUM = 0.9
# Weight decay co-efficient for the optimizer.
_C.OPTIM.WEIGHT_DECAY = 0.0001
# Regex pattern of params for which there will be no weight decay.
_C.OPTIM.NO_DECAY = ".*textual.(embedding|transformer).*(norm.*|bias)"
# Max gradient norm for clipping to avoid exploding gradients.
_C.OPTIM.CLIP_GRAD_NORM = 10
# Wrap our optimizer with Lookahead (https://arxiv.org/abs/1907.08610).
_C.OPTIM.USE_LOOKAHEAD = False
_C.OPTIM.LOOKAHEAD_ALPHA = 0.5
_C.OPTIM.LOOKAHEAD_STEPS = 5
# We set different learning rates for CNN (visual backbone) and rest of
# the model. CNN LR is typically much higher for training from scratch.
# Both LRs undergo same warmup-decay schedules.
# Total batch size (will be distributed evenly across GPUs).
_C.OPTIM.BATCH_SIZE = 256
# Max learning rate for CNN (visual backbone).
_C.OPTIM.CNN_LR = 0.2
# Max learning rate for rest of the model.
_C.OPTIM.LR = 0.001
# Number of iterations to train for, batches are randomly sampled.
_C.OPTIM.NUM_ITERATIONS = 500000
# Number of steps at the start of training for linear LR warmup.
_C.OPTIM.WARMUP_STEPS = 10000
# Learning rate annealing schedule for decay after warmup.
# Possible choices: {"none", "linear", "cosine", "multistep"}.
_C.OPTIM.LR_DECAY_NAME = "cosine"
# Steps to decay LR for "multistep" schedule.
_C.OPTIM.LR_STEPS = []
# Factor to multiply with LR for "multistep" schedule.
_C.OPTIM.LR_GAMMA = 0.1
# Override parameter values from YAML file first, then from override
# list, then add derived params.
self._C = _C
if config_file is not None:
self._C.merge_from_file(config_file)
self._C.merge_from_list(override_list)
self.add_derived_params()
# Make an instantiated object of this class immutable.
self._C.freeze()
def __init__(self,
config_file: Optional[str] = None,
override_list: List[Any] = []):
_C = CN()
_C.VALID_IMAGES = [
'CXR1576_IM-0375-2001.png', 'CXR1581_IM-0378-2001.png',
'CXR3177_IM-1497-2001.png', 'CXR2585_IM-1082-1001.png',
'CXR1125_IM-0082-1001.png', 'CXR3_IM-1384-2001.png',
'CXR1565_IM-0368-1001.png', 'CXR1105_IM-0072-1001-0001.png',
'CXR2874_IM-1280-1001.png', 'CXR1886_IM-0574-1001.png'
]
_C.MODELS = [{
'resnet18': (pretrainedmodels.resnet18(pretrained=None), 512, 224),
'resnet50':
(pretrainedmodels.resnet50(pretrained=None), 2048, 224),
'resnet101':
(pretrainedmodels.resnet101(pretrained=None), 2048, 224),
'resnet152':
(pretrainedmodels.resnet152(pretrained=None), 2048, 224),
'inception_resnet_v2':
(pretrainedmodels.inceptionresnetv2(pretrained=None), 1536, 299)
}]
# _C.MODELS_FEATURE_SIZE = {'resnet18':512, 'resnet50':2048, 'resnet101':2048, 'resnet152':2048,
# 'inception_v3':2048, 'inception_resnet_v2':1536}
# Random seed for NumPy and PyTorch, important for reproducibility.
_C.RANDOM_SEED = 42
# Opt level for mixed precision training using NVIDIA Apex. This can be
# one of {0, 1, 2}. Refer NVIDIA Apex docs for their meaning.
_C.FP16_OPT = 2
# Path to the dataset root, which structure as per README. Path is
# assumed to be relative to project root.
_C.IMAGE_PATH = '/netscratch/gsingh/MIMIC_CXR/DataSet/Indiana_Chest_XRay/Images_2'
_C.TRAIN_JSON_PATH = '/netscratch/gsingh/MIMIC_CXR/DataSet/Indiana_Chest_XRay/iu_xray_train_2.json'
_C.VAL_JSON_PATH = '/netscratch/gsingh/MIMIC_CXR/DataSet/Indiana_Chest_XRay/iu_xray_val_2.json'
_C.TEST_JSON_PATH = '/netscratch/gsingh/MIMIC_CXR/DataSet/Indiana_Chest_XRay/iu_xray_test_2.json'
_C.PRETRAINED_EMDEDDING = False
# Path to .vocab file generated by ``sentencepiece``.
_C.VOCAB_FILE_PATH = "/netscratch/gsingh/MIMIC_CXR/DataSet/Indiana_Chest_XRay/Vocab/indiana.vocab"
# Path to .model file generated by ``sentencepiece``.
_C.VOCAB_MODEL_PATH = "/netscratch/gsingh/MIMIC_CXR/DataSet/Indiana_Chest_XRay/Vocab/indiana.model"
_C.VOCAB_SIZE = 3000
_C.EPOCHS = 1024
_C.BATCH_SIZE = 10
_C.TEST_BATCH_SIZE = 100
_C.ITERATIONS_PER_EPOCHS = 1
_C.WEIGHT_DECAY = 1e-5
_C.NUM_LABELS = 41
_C.IMAGE_SIZE = 299
_C.MAX_SEQUENCE_LENGTH = 130
_C.DROPOUT_RATE = 0.1
_C.D_HEAD = 64
_C.TRAIN_DATASET_LENGTH = 25000
_C.INFERENCE_TIME = False
_C.COMBINED_N_LAYERS = 1
_C.BEAM_SIZE = 50
_C.PADDING_INDEX = 0
_C.EOS_INDEX = 3
_C.SOS_INDEX = 2
_C.USE_BEAM_SEARCH = True
_C.EXTRACTED_FEATURES = False
_C.IMAGE_MODEL_PATH = '/netscratch/gsingh/MIMIC_CXR/Results/Image_Feature_Extraction/MIMIC_CXR_No_ES/model.pth'
_C.EMBEDDING_DIM = 8192
_C.CONTEXT_SIZE = 1024
_C.LR_COMBINED = 1e-4
_C.MAX_LR = 1e-1
_C.SAVED_DATASET = False
_C.MODEL_NAME = 'inception_resnet_v2'
INIT_PATH = '/netscratch/gsingh/MIMIC_CXR/Results/Modified_Transformer/Indiana_15_10_2020_2/'
_C.SAVED_DATASET_PATH_TRAIN = INIT_PATH + 'DataSet/train_dataloader.pth'
_C.SAVED_DATASET_PATH_VAL = INIT_PATH + 'DataSet/val_dataloader.pth'
_C.SAVED_DATASET_PATH_TEST = INIT_PATH + 'DataSet/test_dataloader.pth'
_C.CHECKPOINT_PATH = INIT_PATH + 'CheckPoints'
_C.MODEL_PATH = INIT_PATH + 'combined_model.pth'
_C.MODEL_STATE_DIC = INIT_PATH + 'combined_model_state_dic.pth'
_C.FIGURE_PATH = INIT_PATH + 'Graphs'
_C.CSV_PATH = INIT_PATH
_C.TEST_CSV_PATH = INIT_PATH + 'test_output_image_feature_input.json'
self._C = _C
if config_file is not None:
self._C.merge_from_file(config_file)
self._C.merge_from_list(override_list)
self.add_derived_params()
# Make an instantiated object of this class immutable.
self._C.freeze()
from fvcore.common.config import CfgNode as CN _C = CN() _C.EVAL = CN(new_allowed=True) _C.EVAL.MAX_CLICKS = 100 _C.EVAL.OUTPUT_PROBABILITY_THRESH = 0.5 def get_cfg_defaults(): """Get a yacs CfgNode object with default values for my_project.""" # Return a clone so that the defaults will not be altered # This is for the "local variable" use pattern return _C.clone()
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--model-config',
type=str,
default='./models/configs/rtm3d_dla34_kitti.yaml')
parser.add_argument('--num-workers',
default=1,
type=int,
help='the num of threads for data.')
args = parser.parse_args()
# opt.config = utils.check_file(opt.config) # check file
cfg = config.clone()
if len(args.model_config) > 0:
cfg.merge_from_file(args.model_config)
opt = CfgNode(args.__dict__)
cfg.merge_from_other_cfg(opt)
brg_mean = config.DATASET.MEAN
dr = DatasetReader(config.DATASET.PATH, cfg,
TrainAugmentation(cfg.INPUT_SIZE[0], mean=brg_mean))
dataloader, _, dr = create_dataloader(
config.DATASET.PATH,
cfg,
transform=TrainAugmentation(cfg.INPUT_SIZE[0], mean=brg_mean),
is_training=True)
batch_size = min(1, len(dr))
nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0,
8]) # number of workers
names = cfg.DATASET.OBJs
colors = [[random.randint(0, 255) for _ in range(3)]
from fvcore.common.config import CfgNode from Archs_2D import Register CONFIGS = CfgNode() CONFIGS.INTENSOR_SHAPE = (288, 288) CONFIGS.BATCH_SIZE = 4 CONFIGS.DEVICE = 'cuda' CONFIGS.TRAINING = CfgNode() CONFIGS.TRAINING.LOGDIR = './logdirs/shufflev2_retinanet' CONFIGS.TRAINING.CHECKPOINT_MODE = 'START' #['PRETRAINED', 'RESUME', 'START'] CONFIGS.TRAINING.CHECKPOINT_FILE = './pretrained/mobilenetv2_pretrained.pkl' CONFIGS.DATASET = CfgNode() CONFIGS.DATASET.PATH = './datasets/data/kitti' CONFIGS.DATASET.MEAN = [95.87739305, 98.76049672, 93.83309082] CONFIGS.DATALOADER = CfgNode() CONFIGS.DATALOADER.SAMPLER_TRAIN = 'TrainingSampler' # Solver # ---------------------------------------------------------------------------- # CONFIGS.SOLVER = CfgNode() # See detectron2/solver/build.py for LR scheduler options CONFIGS.SOLVER.LR_SCHEDULER_NAME = "WarmupMultiStepLR" CONFIGS.SOLVER.MAX_ITER = 400000 CONFIGS.SOLVER.BASE_LR = 0.01 CONFIGS.SOLVER.MOMENTUM = 0.9
def get_shapenet_cfg():
cfg = CN()
cfg.MODEL = CN()
cfg.MODEL.BACKBONE = "resnet50"
cfg.MODEL.VOXEL_ON = False
cfg.MODEL.MESH_ON = False
# ------------------------------------------------------------------------ #
# Checkpoint
# ------------------------------------------------------------------------ #
cfg.MODEL.CHECKPOINT = "" # path to checkpoint
# ------------------------------------------------------------------------ #
# Voxel Head
# ------------------------------------------------------------------------ #
cfg.MODEL.VOXEL_HEAD = CN()
# The number of convs in the voxel head and the number of channels
cfg.MODEL.VOXEL_HEAD.NUM_CONV = 0
cfg.MODEL.VOXEL_HEAD.CONV_DIM = 256
# Normalization method for the convolution layers. Options: "" (no norm), "GN"
cfg.MODEL.VOXEL_HEAD.NORM = ""
# The number of depth channels for the predicted voxels
cfg.MODEL.VOXEL_HEAD.VOXEL_SIZE = 28
cfg.MODEL.VOXEL_HEAD.LOSS_WEIGHT = 1.0
cfg.MODEL.VOXEL_HEAD.CUBIFY_THRESH = 0.0
# voxel only iterations
cfg.MODEL.VOXEL_HEAD.VOXEL_ONLY_ITERS = 100
##
cfg.MODEL.VOXEL_HEAD.TCONV_USE_BIAS = False
cfg.MODEL.VOXEL_HEAD.LEAKY_VALUE = 0.2
##
# ------------------------------------------------------------------------ #
# Mesh Head
# ------------------------------------------------------------------------ #
cfg.MODEL.MESH_HEAD = CN()
cfg.MODEL.MESH_HEAD.NAME = "VoxMeshHead"
# Numer of stages
cfg.MODEL.MESH_HEAD.NUM_STAGES = 1
cfg.MODEL.MESH_HEAD.NUM_GRAPH_CONVS = 1 # per stage
cfg.MODEL.MESH_HEAD.GRAPH_CONV_DIM = 256
cfg.MODEL.MESH_HEAD.GRAPH_CONV_INIT = "normal"
# Mesh sampling
cfg.MODEL.MESH_HEAD.GT_NUM_SAMPLES = 5000
cfg.MODEL.MESH_HEAD.PRED_NUM_SAMPLES = 5000
# loss weights
cfg.MODEL.MESH_HEAD.CHAMFER_LOSS_WEIGHT = 1.0
cfg.MODEL.MESH_HEAD.NORMALS_LOSS_WEIGHT = 1.0
cfg.MODEL.MESH_HEAD.EDGE_LOSS_WEIGHT = 1.0
# Init ico_sphere level (only for when voxel_on is false)
cfg.MODEL.MESH_HEAD.ICO_SPHERE_LEVEL = -1
# ------------------------------------------------------------------------ #
# Solver
# ------------------------------------------------------------------------ #
cfg.SOLVER = CN()
cfg.SOLVER.LR_SCHEDULER_NAME = "constant" # {'constant', 'cosine'}
cfg.SOLVER.BATCH_SIZE = 32
cfg.SOLVER.BATCH_SIZE_EVAL = 8
cfg.SOLVER.NUM_EPOCHS = 25
cfg.SOLVER.BASE_LR = 0.0001
cfg.SOLVER.OPTIMIZER = "adam" # {'sgd', 'adam'}
cfg.SOLVER.MOMENTUM = 0.9
cfg.SOLVER.WARMUP_ITERS = 500
cfg.SOLVER.WARMUP_FACTOR = 0.1
cfg.SOLVER.CHECKPOINT_PERIOD = 24949 # in iters
cfg.SOLVER.LOGGING_PERIOD = 50 # in iters
# stable training
cfg.SOLVER.SKIP_LOSS_THRESH = 50.0
cfg.SOLVER.LOSS_SKIP_GAMMA = 0.9
# ------------------------------------------------------------------------ #
# Datasets
# ------------------------------------------------------------------------ #
cfg.DATASETS = CN()
cfg.DATASETS.NAME = "shapenet"
# ------------------------------------------------------------------------ #
# Misc options
# ------------------------------------------------------------------------ #
# Directory where output files are written
cfg.OUTPUT_DIR = "./output"
return cfg
'''Configs''' from fvcore.common.config import CfgNode # ----------------------------------------------------------------------------- # Config definition # ----------------------------------------------------------------------------- _C = CfgNode() # ----------------------------------------------------------------------------- # Data options # ----------------------------------------------------------------------------- _C.DATA = CfgNode() _C.DATA.NUM_WORKERS = 0 _C.DATA.PIN_MEMORY = True _C.DATA.ROOT = './.data' # ----------------------------------------------------------------------------- # Training options # ----------------------------------------------------------------------------- _C.TRAIN = CfgNode() # Total mini-batch size. _C.TRAIN.BATCH_SIZE = 128 # Maximal number of epochs. _C.TRAIN.MAX_EPOCH = 300
#!/usr/bin/env python3 # Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. """Configs.""" from fvcore.common.config import CfgNode from . import custom_config # ----------------------------------------------------------------------------- # Config definition # ----------------------------------------------------------------------------- _C = CfgNode() # ---------------------------------------------------------------------------- # # Batch norm options # ---------------------------------------------------------------------------- # _C.BN = CfgNode() # Precise BN stats. _C.BN.USE_PRECISE_STATS = False # Number of samples use to compute precise bn. _C.BN.NUM_BATCHES_PRECISE = 200 # Weight decay value that applies on BN. _C.BN.WEIGHT_DECAY = 0.0 # Norm type, options include `batchnorm`, `sub_batchnorm`, `sync_batchnorm` _C.BN.NORM_TYPE = "batchnorm" # Parameter for SubBatchNorm, where it splits the batch dimension into
from fvcore.common.config import CfgNode
from Archs_3D import Register
CONFIGS = CfgNode()
CONFIGS.INTENSOR_SHAPE = (224, 224)
CONFIGS.BATCH_SIZE = 4
CONFIGS.DEVICE = 'cuda'
CONFIGS.TRAINING = CfgNode()
CONFIGS.TRAINING.LOGDIR = './logdirs/mobiv2_retinanet'
CONFIGS.TRAINING.EPOCHS = 700
CONFIGS.TRAINING.CHECKPOINT_MODE = 'PRETRAINED' #['PRETRAINED', 'RESUME', 'START']
CONFIGS.TRAINING.CHECKPOINT_FILE = './pretrained/mobilenetv2_pretrained.pkl'
CONFIGS.DATASET = CfgNode()
CONFIGS.DATASET.PATH = './datasets/data/kitti'
CONFIGS.DATASET.MEAN = [95.87739305, 98.76049672, 93.83309082]
CONFIGS.DATASET.DIM_MEAN = [[1.52607842, 1.62858147, 3.88396124],
[2.20649159, 1.90197734, 5.07812564],
[3.25207685, 2.58505032, 10.10703568],
[1.76067766, 0.6602296, 0.84220464],
[1.27538462, 0.59506787, 0.80180995],
[1.73712792, 0.59677122, 1.76338868],
[3.52905882, 2.54368627, 16.09707843],
[1.9074177, 1.51386831, 3.57683128]]
CONFIGS.DATALOADER = CfgNode()
CONFIGS.DATALOADER.SAMPLER_TRAIN = 'TrainingSampler'
# Solver
# ---------------------------------------------------------------------------- #
CONFIGS.SOLVER = CfgNode()
from fvcore.common.config import CfgNode as CN
_C = CN()
_C.TASK = 'classification'
_C.TRAIN_DIR = ('data/train', )
_C.VAL_DIR = ('data/val', )
_C.OUTPUT_DIR = 'baseline'
_C.EPOCH = 60
_C.BATCH_SIZE = 64
_C.MIXED_PRECISION = False
_C.QUANTIZATION_TRAINING = False
_C.TENSORBOARD = True
_C.MULTI_GPU = True
_C.MODEL = CN()
_C.MODEL.NAME = 'resnet50'
_C.MODEL.NUM_CLASSES = 3
_C.MODEL.CLASSES = (None, )
_C.MODEL.TEMPERATURE_SCALING = 1
_C.MODEL.AUTOML = False
_C.MODEL.AUTOML_TRIALS = 1000
_C.SOLVER = CN()
_C.SOLVER.NAME = 'sgd'
_C.SOLVER.LR = 0.0002
_C.SOLVER.WEIGHT_DECAY = 0.00001
_C.SOLVER.SCHEDULER = CN()
node.backbone.hrnet.stage2.subsample.strides = [2]
node.backbone.hrnet.stage3.subsample = create_subsample_layer(
node.backbone.hrnet.stage3, key='subsample', num_layers=1)
node.backbone.hrnet.stage3.subsample.num_filters = [192, 384]
node.backbone.hrnet.stage3.subsample.kernel_sizes = [3, 3]
node.backbone.hrnet.stage3.subsample.strides = [2, 2]
node.backbone.hrnet.final_conv = create_conv_layers(node.backbone.hrnet,
key='final_conv')
node.backbone.hrnet.final_conv.num_filters = 2048
return node.backbone
_C = CN()
# General
_C.num_gpus = 1
_C.local_rank = 0
_C.use_cuda = True
_C.log_file = '/tmp/logs/'
_C.output_folder = 'output'
_C.summary_folder = 'summaries'
_C.results_folder = 'results'
_C.code_folder = 'code'
_C.summary_steps = 100
_C.img_summary_steps = 100
_C.hd_img_summary_steps = 1000
