from yacs.config import CfgNode as CN _C = CN() _C.ROBOT_DESCRIPTION = '/robot_description' _C.ROSTOPIC_JOINT_STATES = '/joint_states' # base frame for the arm _C.ROBOT_BASE_FRAME = 'yumi_body' _C.CLASS = 'Yumi' _C.JOINT_SPEED_TOPIC = '/joint_speed' # inverse kinematics position tolerance (m) _C.IK_POSITION_TOLERANCE = 0.01 # inverse kinematics orientation tolerance (rad) _C.IK_ORIENTATION_TOLERANCE = 0.04 _C.MAX_JOINT_ERROR = 0.01 _C.MAX_JOINT_VEL_ERROR = 0.04 _C.MAX_EE_POS_ERROR = 0.01 # real part of the quaternion difference should be # greater than 1-error _C.MAX_EE_ORI_ERROR = 0.01 _C.TIMEOUT_LIMIT = 4 # reset position for the robot in pybullet _C.PYBULLET_RESET_POS = [0, 0, -0.1] # reset orientation (euler angles) for the robot in pybullet _C.PYBULLET_RESET_ORI = [0, 0, 0] # damped inverse kinematics value _C.PYBULLET_IK_DAMPING = 0.0005
import os import sys import shutil import argparse from yacs.config import CfgNode as CN _C = CN() # SOLVER related parameters _C.SOLVER = CN() _C.SOLVER.gpu = (0, ) # The gpu ids _C.SOLVER.logdir = 'logs' # Directory where to write event logs _C.SOLVER.ckpt = '' # Restore weights from checkpoint file _C.SOLVER.run = 'train' # Choose from train or test _C.SOLVER.type = 'sgd' # Choose from sgd or adam _C.SOLVER.max_iter = 160000 # Maximum training iterations _C.SOLVER.test_iter = 100 # Test steps in testing phase _C.SOLVER.test_every_iter = 1000 # Test model every n training steps _C.SOLVER.lr_type = 'step' # Learning rate type: step or cos _C.SOLVER.learning_rate = 0.1 # Initial learning rate _C.SOLVER.gamma = 0.1 # Learning rate step-wise decay _C.SOLVER.step_size = (40000, ) # Learning rate step size. _C.SOLVER.ckpt_num = 100 # The number of checkpoint kept _C.SOLVER.var_name = ('_name', ) # Variable names used for finetuning _C.SOLVER.ignore_var_name = ('_name', ) # Ignore variable names when loading ckpt _C.SOLVER.verbose = False # Whether to output some messages # DATA related parameters _C.DATA = CN() _C.DATA.train = CN()
from yacs.config import CfgNode as CN cfg = CN() cfg.MODEL = CN() # match default boxes to any ground truth with jaccard overlap higher than a threshold (0.5) cfg.MODEL.THRESHOLD = 0.5 cfg.MODEL.NUM_CLASSES = 21 # Hard negative mining cfg.MODEL.NEG_POS_RATIO = 3 cfg.MODEL.CENTER_VARIANCE = 0.1 cfg.MODEL.SIZE_VARIANCE = 0.2 # ---------------------------------------------------------------------------- # # Backbone # ---------------------------------------------------------------------------- # cfg.MODEL.BACKBONE = CN() cfg.MODEL.BACKBONE.NAME = 'vgg' cfg.MODEL.BACKBONE.OUT_CHANNELS = (512, 1024, 512, 256, 256, 256) cfg.MODEL.BACKBONE.PRETRAINED = True cfg.MODEL.BACKBONE.INPUT_CHANNELS = 3 # ----------------------------------------------------------------------------- # PRIORS # ----------------------------------------------------------------------------- cfg.MODEL.PRIORS = CN() # X, Y cfg.MODEL.PRIORS.FEATURE_MAPS = [[38, 38], [19, 19], [10, 10], [5, 5], [3, 3], [1, 1]] # X, Y cfg.MODEL.PRIORS.STRIDES = [[8, 8], [16, 16], [32, 32], [64, 64], [100, 100],
from __future__ import absolute_import from __future__ import division from __future__ import print_function from yacs.config import CfgNode as CN # pose_resnet related params POSE_RESNET = CN() POSE_RESNET.NUM_LAYERS = 50 POSE_RESNET.DECONV_WITH_BIAS = False POSE_RESNET.NUM_DECONV_LAYERS = 3 POSE_RESNET.NUM_DECONV_FILTERS = [256, 256, 256] POSE_RESNET.NUM_DECONV_KERNELS = [4, 4, 4] POSE_RESNET.FINAL_CONV_KERNEL = 1 POSE_RESNET.PRETRAINED_LAYERS = ['*'] # pose_multi_resoluton_net related params POSE_HIGH_RESOLUTION_NET = CN() POSE_HIGH_RESOLUTION_NET.PRETRAINED_LAYERS = ['*'] POSE_HIGH_RESOLUTION_NET.STEM_INPLANES = 64 POSE_HIGH_RESOLUTION_NET.FINAL_CONV_KERNEL = 1 stage2 = { 'CN()': CN(), 'NUM_MODULES': 1, 'NUM_BRANCHES': 2, 'NUM_BLOCKS': [4, 4], 'NUM_CHANNELS': [32, 64], 'BLOCK': 'BASIC', 'FUSE_METHOD': 'SUM' }
# Copyright (c) SenseTime. All Rights Reserved. from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals from yacs.config import CfgNode as CN __C = CN() cfg = __C __C.META_ARC = "siamgat_googlenet" __C.CUDA = True # ------------------------------------------------------------------------ # # Training options # ------------------------------------------------------------------------ # __C.TRAIN = CN() __C.TRAIN.EXEMPLAR_SIZE = 127 __C.TRAIN.SEARCH_SIZE = 287 __C.TRAIN.OUTPUT_SIZE = 25 __C.TRAIN.RESUME = '' __C.TRAIN.PRETRAINED = ''
import os from yacs.config import CfgNode as CN _C = CN() # ----------------------------------------------------------------------------- # Misc # ----------------------------------------------------------------------------- _C.OUTPUT_DIR = '' _C.GPUS = (0, ) _C.WORKERS = 4 # Logging frequency _C.PRINT_FREQ = 20 # Checkpoint frequency _C.CKPT_FREQ = 5000 # ----------------------------------------------------------------------------- # CUDNN # ----------------------------------------------------------------------------- _C.CUDNN = CN() _C.CUDNN.BENCHMARK = True _C.CUDNN.DETERMINISTIC = False _C.CUDNN.ENABLED = True # ----------------------------------------------------------------------------- # Model # ----------------------------------------------------------------------------- _C.MODEL = CN() _C.MODEL.META_ARCHITECTURE = 'panoptic_deeplab' # pretrained model (including decoder, head, etc) on other dataset
# ----------------------------------------------------------------------------- # Convention about Training / Test specific parameters # ----------------------------------------------------------------------------- # Whenever an argument can be either used for training or for testing, the # corresponding name will be post-fixed by a _TRAIN for a training parameter, # or _TEST for a test-specific parameter. # For example, the number of images during training will be # IMAGES_PER_BATCH_TRAIN, while the number of images for testing will be # IMAGES_PER_BATCH_TEST # ----------------------------------------------------------------------------- # Config definition # ----------------------------------------------------------------------------- _C = CN() _C.MODEL = CN() _C.MODEL.RPN_ONLY = False _C.MODEL.MASK_ON = False _C.MODEL.FCOS_ON = False _C.MODEL.EMBED_MASK_ON = False _C.MODEL.RETINANET_ON = False _C.MODEL.KEYPOINT_ON = False _C.MODEL.DEVICE = "cuda" _C.MODEL.META_ARCHITECTURE = "GeneralizedRCNN" _C.MODEL.CLS_AGNOSTIC_BBOX_REG = False # If the WEIGHT starts with a catalog://, like :R-50, the code will look for # the path in paths_catalog. Else, it will use it as the specified absolute # path
# ----------------------------------------------------------------------------- # Convention about Training / Test specific parameters # ----------------------------------------------------------------------------- # Whenever an argument can be either used for training or for testing, the # corresponding name will be post-fixed by a _TRAIN for a training parameter, # or _TEST for a test-specific parameter. # For example, the maximum image side during training will be # INPUT.MAX_SIZE_TRAIN, while for testing it will be # INPUT.MAX_SIZE_TEST # ----------------------------------------------------------------------------- # Config definition # ----------------------------------------------------------------------------- _C = CN() _C.MODEL = CN() _C.MODEL.RPN_ONLY = False _C.MODEL.MASK_ON = False _C.MODEL.FCOS_ON = False _C.MODEL.EMBED_MASK_ON = False _C.MODEL.MASKIOU_ON = False _C.MODEL.MASKIOU_LOSS_WEIGHT = 1.0 _C.MODEL.RETINANET_ON = False _C.MODEL.KEYPOINT_ON = False _C.MODEL.DEVICE = "cuda" _C.MODEL.META_ARCHITECTURE = "GeneralizedRCNN" _C.MODEL.CLS_AGNOSTIC_BBOX_REG = False # If the WEIGHT starts with a catalog://, like :R-50, the code will look for
"""Default setting in training/testing""" from yacs.config import CfgNode as CN _C = CN() # ---------------------------------------------------------------------------- # # Distributed DataParallel setting: DDP_CONFIG # ---------------------------------------------------------------------------- # _C.DDP_CONFIG = CN(new_allowed=False) # Number of nodes for distributed training _C.DDP_CONFIG.WORLD_SIZE = 1 # Node rank for distributed training _C.DDP_CONFIG.WORLD_RANK = 0 # Number of GPUs to use _C.DDP_CONFIG.GPU_WORLD_SIZE = 8 # GPU rank for distributed training _C.DDP_CONFIG.GPU_WORLD_RANK = 0 # Master node _C.DDP_CONFIG.DIST_URL = 'tcp://127.0.0.1:10001' # A list of IP addresses for each node _C.DDP_CONFIG.WOLRD_URLS = ['127.0.0.1'] # Whether to turn on automatic ranking match. _C.DDP_CONFIG.AUTO_RANK_MATCH = True # distributed backend _C.DDP_CONFIG.DIST_BACKEND = 'nccl' # Current GPU id. _C.DDP_CONFIG.GPU = 0 # Whether to use distributed training or simply use dataparallel. _C.DDP_CONFIG.DISTRIBUTED = True
# ------------------------------------------------------------------------------ # Copyright (c) Microsoft # Licensed under the MIT License. # Written by Bin Xiao ([email protected]) # Modified by Ke Sun ([email protected]), Tianheng Cheng([email protected]) # ------------------------------------------------------------------------------ from __future__ import absolute_import from __future__ import division from __future__ import print_function from yacs.config import CfgNode as CN _C = CN() _C.OUTPUT_DIR = 'output' _C.LOG_DIR = 'log' _C.GPUS = (0, 1, 2, 4) _C.WORKERS = 16 _C.PRINT_FREQ = 20 _C.AUTO_RESUME = False _C.PIN_MEMORY = True # Cudnn related params _C.CUDNN = CN() _C.CUDNN.BENCHMARK = True _C.CUDNN.DETERMINISTIC = False _C.CUDNN.ENABLED = True # common params for NETWORK _C.MODEL = CN()
# Copyright 2020 Toyota Research Institute. All rights reserved. """Default kp2d configuration parameters (overridable in configs/*.yaml) """ import os from yacs.config import CfgNode as CN ######################################################################################################################## cfg = CN() cfg.name = '' # Run name cfg.debug = True # Debugging flag ######################################################################################################################## ### ARCH ######################################################################################################################## cfg.arch = CN() cfg.arch.seed = 42 # Random seed for Pytorch/Numpy initialization cfg.arch.epochs = 50 # Maximum number of epochs ######################################################################################################################## ### WANDB ######################################################################################################################## cfg.wandb = CN() cfg.wandb.dry_run = True # Wandb dry-run (not logging) cfg.wandb.name = '' # Wandb run name cfg.wandb.project = os.environ.get("WANDB_PROJECT", "") # Wandb project cfg.wandb.entity = os.environ.get("WANDB_ENTITY", "") # Wandb entity cfg.wandb.tags = [] # Wandb tags cfg.wandb.dir = '' # Wandb save folder ######################################################################################################################## ### MODEL ######################################################################################################################## cfg.model = CN()
# ----------------------------------------------------------------------------- # Convention about Training / Test specific parameters # ----------------------------------------------------------------------------- # Whenever an argument can be either used for training or for testing, the # corresponding name will be post-fixed by a _TRAIN for a training parameter, # or _TEST for a test-specific parameter. # For example, the number of images during training will be # IMAGES_PER_BATCH_TRAIN, while the number of images for testing will be # IMAGES_PER_BATCH_TEST # ----------------------------------------------------------------------------- # Config definition # ----------------------------------------------------------------------------- _C = CN() _C.MODEL = CN() _C.MODEL.RPN_ONLY = False _C.MODEL.MASK_ON = False _C.MODEL.FCOS_ON = False _C.MODEL.KE_ON = False _C.MODEL.BOUNDARY_ON = False _C.MODEL.MSR_ON = False _C.MODEL.RETINANET_ON = False _C.MODEL.KEYPOINT_ON = False _C.MODEL.DEVICE = "cuda" _C.MODEL.META_ARCHITECTURE = "GeneralizedRCNN" _C.MODEL.CLS_AGNOSTIC_BBOX_REG = False # If the WEIGHT starts with a catalog://, like :R-50, the code will look for
from yacs.config import CfgNode as CN _C = CN() # Model _C.MODEL = CN() _C.MODEL.ARCH = "se_resnext50_32x4d" # check python train.py -h for available models _C.MODEL.IMG_SIZE = 224 # Train _C.TRAIN = CN() _C.TRAIN.OPT = "adam" # adam or sgd _C.TRAIN.WORKERS = 4 _C.TRAIN.LR = 0.0003 _C.TRAIN.LR_DECAY_STEP = 20 _C.TRAIN.LR_DECAY_RATE = 0.2 _C.TRAIN.MOMENTUM = 0.9 _C.TRAIN.WEIGHT_DECAY = 0.0 _C.TRAIN.BATCH_SIZE = 64 _C.TRAIN.EPOCHS = 100 _C.TRAIN.AGE_STDDEV = 1.0 # Test _C.TEST = CN() _C.TEST.WORKERS = 4 _C.TEST.BATCH_SIZE = 64
# Copyright (c) SenseTime. All Rights Reserved. from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals from yacs.config import CfgNode as CN __C = CN() cfg = __C __C.META_ARC = "siamrpn_r50_l234_dwxcorr" __C.CUDA = True # ------------------------------------------------------------------------ # # Training options # ------------------------------------------------------------------------ # __C.TRAIN = CN() # Anchor Target # Positive anchor threshold __C.TRAIN.THR_HIGH = 0.6 # Negative anchor threshold __C.TRAIN.THR_LOW = 0.3 # Number of negative __C.TRAIN.NEG_NUM = 16 # Number of positive
from yacs.config import CfgNode as CN # ----------------------------------------------------------------------------- # Config definition # ----------------------------------------------------------------------------- _C = CN() # ----------------------------------------------------------------------------- # System # ----------------------------------------------------------------------------- _C.SYSTEM = CN() _C.SYSTEM.NUM_GPUS = 4 _C.SYSTEM.NUM_CPUS = 4 # Run distributed training using DistributedDataparallel model _C.SYSTEM.DISTRIBUTED = False _C.SYSTEM.PARALLEL = 'DP' # ----------------------------------------------------------------------------- # Model # ----------------------------------------------------------------------------- _C.MODEL = CN() # Model architectures defined in the package: unet_super, super, fpn, unet_residual_3d _C.MODEL.ARCHITECTURE = 'unet_3d' _C.MODEL.BLOCK_TYPE = 'residual' _C.MODEL.BACKBONE = 'resnet' _C.MODEL.DEPLOY_MODE = False # Number of filters per unet block _C.MODEL.FILTERS = [28, 36, 48, 64, 80]
# Copyright (c) SenseTime. All Rights Reserved. from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals from yacs.config import CfgNode as CN __C = CN() cfg = __C __C.META_ARC = "siamrpn_r50_l234_dwxcorr" __C.CUDA = True # ------------------------------------------------------------------------ # # Training options # ------------------------------------------------------------------------ # __C.TRAIN = CN() # Anchor Target # Positive anchor threshold __C.TRAIN.THR_HIGH = 0.6 # Negative anchor threshold __C.TRAIN.THR_LOW = 0.3 # Number of negative __C.TRAIN.NEG_NUM = 16
from yacs.config import CfgNode from yacs.config import CfgNode as CN _C = CN() _C.MODEL = CN() _C.MODEL.NAME = "" _C.MODEL.SUB_NAME = "" _C.MODEL.H_SIZE = (1000, 300) _C.MODEL.USE_IOU = True _C.DATASET = CN() _C.DATASET.NAME = "" _C.DATASET.FEAT_TYPE = "ddpn" # ddpn / plclc _C.DATASET.TRAIN_SIZE = 1.0 _C.TRAIN = CN() _C.TRAIN.BATCH_SIZE = 500 _C.TRAIN.LR = 0.01 _C.TRAIN.WEIGHT_DECAY = 0 _C.TRAIN.DEVICE = 0 _C.TRAIN.EPOCH = 5 _C.TRAIN.N_PARALLEL = 4 _C.LOG = CN() _C.LOG.OUTDIR = "./" _C.LOG.LOG_FILE = "log.json" _C.LOG.NEPTUNE = False _C.TEST = CN() _C.TEST.CHECKPOINT = ""
import functools import inspect import logging import os import shutil import warnings from collections.abc import Iterable from dataclasses import asdict from typing import Any import torch_geometric.graphgym.register as register from torch_geometric.data.makedirs import makedirs try: # Define global config object from yacs.config import CfgNode as CN cfg = CN() except ImportError: cfg = None warnings.warn("Could not define global config object. Please install " "'yacs' for using the GraphGym experiment manager via " "'pip install yacs'.") def set_cfg(cfg): r''' This function sets the default config value. 1) Note that for an experiment, only part of the arguments will be used The remaining unused arguments won't affect anything. So feel free to register any argument in graphgym.contrib.config 2) We support *at most* two levels of configs, e.g., cfg.dataset.name
# ----------------------------------------------------------------------------- # Convention about Training / Test specific parameters # ----------------------------------------------------------------------------- # Whenever an argument can be either used for training or for testing, the # corresponding name will be post-fixed by a _TRAIN for a training parameter, # or _TEST for a test-specific parameter. # For example, the maximum image side during training will be # INPUT.MAX_SIZE_TRAIN, while for testing it will be # INPUT.MAX_SIZE_TEST # ----------------------------------------------------------------------------- # Config definition # ----------------------------------------------------------------------------- _C = CN() _C.MODEL = CN() _C.MODEL.RPN_ONLY = False _C.MODEL.MASK_ON = False _C.MODEL.RETINANET_ON = False _C.MODEL.KEYPOINT_ON = False _C.MODEL.DEVICE = "cuda" _C.MODEL.META_ARCHITECTURE = "GeneralizedRCNN" _C.MODEL.CLS_AGNOSTIC_BBOX_REG = False # If the WEIGHT starts with a catalog://, like :R-50, the code will look for # the path in paths_catalog. Else, it will use it as the specified absolute # path _C.MODEL.WEIGHT = ""
def set_cfg(cfg): r''' This function sets the default config value. 1) Note that for an experiment, only part of the arguments will be used The remaining unused arguments won't affect anything. So feel free to register any argument in graphgym.contrib.config 2) We support *at most* two levels of configs, e.g., cfg.dataset.name :return: configuration use by the experiment. ''' if cfg is None: return cfg # ----------------------------------------------------------------------- # # Basic options # ----------------------------------------------------------------------- # # Set print destination: stdout / file / both cfg.print = 'both' # Select device: 'cpu', 'gpu', 'tpu', 'auto' cfg.accelerator = 'auto' # number of devices: eg. for 2 GPU set cfg.devices=2 cfg.devices = None # Output directory cfg.out_dir = 'results' # Config name (in out_dir) cfg.cfg_dest = 'config.yaml' # Names of registered custom metric funcs to be used (use defaults if none) cfg.custom_metrics = [] # Random seed cfg.seed = 0 # Print rounding cfg.round = 4 # Tensorboard support for each run cfg.tensorboard_each_run = False # Tensorboard support for aggregated results cfg.tensorboard_agg = True # Additional num of worker for data loading cfg.num_workers = 0 # Max threads used by PyTorch cfg.num_threads = 6 # The metric for selecting the best epoch for each run cfg.metric_best = 'auto' # argmax or argmin in aggregating results cfg.metric_agg = 'argmax' # If visualize embedding. cfg.view_emb = False # If get GPU usage cfg.gpu_mem = False # If do benchmark analysis cfg.benchmark = False # ----------------------------------------------------------------------- # # Globally shared variables: # These variables will be set dynamically based on the input dataset # Do not directly set them here or in .yaml files # ----------------------------------------------------------------------- # cfg.share = CN() # Size of input dimension cfg.share.dim_in = 1 # Size of out dimension, i.e., number of labels to be predicted cfg.share.dim_out = 1 # Number of dataset splits: train/val/test cfg.share.num_splits = 1 # ----------------------------------------------------------------------- # # Dataset options # ----------------------------------------------------------------------- # cfg.dataset = CN() # Name of the dataset cfg.dataset.name = 'Cora' # if PyG: look for it in Pytorch Geometric dataset # if NetworkX/nx: load data in NetworkX format cfg.dataset.format = 'PyG' # Dir to load the dataset. If the dataset is downloaded, this is the # cache dir cfg.dataset.dir = './datasets' # Task: node, edge, graph, link_pred cfg.dataset.task = 'node' # Type of task: classification, regression, classification_binary # classification_multi cfg.dataset.task_type = 'classification' # Transductive / Inductive # Graph classification is always inductive cfg.dataset.transductive = True # Split ratio of dataset. Len=2: Train, Val. Len=3: Train, Val, Test cfg.dataset.split = [0.8, 0.1, 0.1] # Whether to shuffle the graphs for splitting cfg.dataset.shuffle_split = True # Whether random split or use custom split: random / custom cfg.dataset.split_mode = 'random' # Whether to use an encoder for general attribute features cfg.dataset.encoder = True # Name of general encoder cfg.dataset.encoder_name = 'db' # If add batchnorm after general encoder cfg.dataset.encoder_bn = True # Whether to use an encoder for the node features cfg.dataset.node_encoder = False # Name of node encoder cfg.dataset.node_encoder_name = 'Atom' # If add batchnorm after node encoder cfg.dataset.node_encoder_bn = True # Whether to use an encoder for the edge features cfg.dataset.edge_encoder = False # Name of edge encoder cfg.dataset.edge_encoder_name = 'Bond' # If add batchnorm after edge encoder cfg.dataset.edge_encoder_bn = True # Dimension of the encoded features. # For now the node and edge encoding dimensions # are the same. cfg.dataset.encoder_dim = 128 # Dimension for edge feature. Updated by the real dim of the dataset cfg.dataset.edge_dim = 128 # ============== Link/edge tasks only # all or disjoint cfg.dataset.edge_train_mode = 'all' # Used in disjoint edge_train_mode. The proportion of edges used for # message-passing cfg.dataset.edge_message_ratio = 0.8 # The ratio of negative samples to positive samples cfg.dataset.edge_negative_sampling_ratio = 1.0 # Whether resample disjoint when dataset.edge_train_mode is 'disjoint' cfg.dataset.resample_disjoint = False # Whether resample negative edges at training time (link prediction only) cfg.dataset.resample_negative = False # What transformation function is applied to the dataset cfg.dataset.transform = 'none' # Whether cache the splitted dataset # NOTE: it should be cautiouslly used, as cached dataset may not have # exactly the same setting as the config file cfg.dataset.cache_save = False cfg.dataset.cache_load = False # Whether remove the original node features in the dataset cfg.dataset.remove_feature = False # Simplify TU dataset for synthetic tasks cfg.dataset.tu_simple = True # Convert to undirected graph (save 2*E edges) cfg.dataset.to_undirected = False # dataset location: local, snowflake cfg.dataset.location = 'local' # Define label: Table name cfg.dataset.label_table = 'none' # Define label: Column name cfg.dataset.label_column = 'none' # ----------------------------------------------------------------------- # # Training options # ----------------------------------------------------------------------- # cfg.train = CN() # Total graph mini-batch size cfg.train.batch_size = 16 # Sampling strategy for a train loader cfg.train.sampler = 'full_batch' # Minibatch node cfg.train.sample_node = False # Num of sampled node per graph cfg.train.node_per_graph = 32 # Radius: same, extend. same: same as cfg.gnn.layers_mp, extend: layers+1 cfg.train.radius = 'extend' # Evaluate model on test data every eval period epochs cfg.train.eval_period = 10 # Option to skip training epoch evaluation cfg.train.skip_train_eval = False # Save model checkpoint every checkpoint period epochs cfg.train.ckpt_period = 100 # Enabling checkpoint, set False to disable and save I/O cfg.train.enable_ckpt = True # Resume training from the latest checkpoint in the output directory cfg.train.auto_resume = False # The epoch to resume. -1 means resume the latest epoch. cfg.train.epoch_resume = -1 # Clean checkpoint: only keep the last ckpt cfg.train.ckpt_clean = True # Number of iterations per epoch (for sampling based loaders only) cfg.train.iter_per_epoch = 32 # GraphSAINTRandomWalkSampler: random walk length cfg.train.walk_length = 4 # NeighborSampler: number of sampled nodes per layer cfg.train.neighbor_sizes = [20, 15, 10, 5] # ----------------------------------------------------------------------- # # Validation options # ----------------------------------------------------------------------- # cfg.val = CN() # Minibatch node cfg.val.sample_node = False # Sampling strategy for a val/test loader cfg.val.sampler = 'full_batch' # Num of sampled node per graph cfg.val.node_per_graph = 32 # Radius: same, extend. same: same as cfg.gnn.layers_mp, extend: layers+1 cfg.val.radius = 'extend' # ----------------------------------------------------------------------- # # Model options # ----------------------------------------------------------------------- # cfg.model = CN() # Model type to use cfg.model.type = 'gnn' # Auto match computational budget, match upper bound / lower bound cfg.model.match_upper = True # Loss function: cross_entropy, mse cfg.model.loss_fun = 'cross_entropy' # size average for loss function. 'mean' or 'sum' cfg.model.size_average = 'mean' # Threshold for binary classification cfg.model.thresh = 0.5 # ============== Link/edge tasks only # Edge decoding methods. # - dot: compute dot(u, v) to predict link (binary) # - cosine_similarity: use cosine similarity (u, v) to predict link ( # binary) # - concat: use u||v followed by an nn.Linear to obtain edge embedding # (multi-class) cfg.model.edge_decoding = 'dot' # =================================== # ================== Graph tasks only # Pooling methods. # - add: global add pool # - mean: global mean pool # - max: global max pool cfg.model.graph_pooling = 'add' # =================================== # ----------------------------------------------------------------------- # # GNN options # ----------------------------------------------------------------------- # cfg.gnn = CN() # Prediction head. Use cfg.dataset.task by default cfg.gnn.head = 'default' # Number of layers before message passing cfg.gnn.layers_pre_mp = 0 # Number of layers for message passing cfg.gnn.layers_mp = 2 # Number of layers after message passing cfg.gnn.layers_post_mp = 0 # Hidden layer dim. Automatically set if train.auto_match = True cfg.gnn.dim_inner = 16 # Type of graph conv: generalconv, gcnconv, sageconv, gatconv, ... cfg.gnn.layer_type = 'generalconv' # Stage type: 'stack', 'skipsum', 'skipconcat' cfg.gnn.stage_type = 'stack' # How many layers to skip each time cfg.gnn.skip_every = 1 # Whether use batch norm cfg.gnn.batchnorm = True # Activation cfg.gnn.act = 'relu' # Dropout cfg.gnn.dropout = 0.0 # Aggregation type: add, mean, max # Note: only for certain layers that explicitly set aggregation type # e.g., when cfg.gnn.layer_type = 'generalconv' cfg.gnn.agg = 'add' # Normalize adj cfg.gnn.normalize_adj = False # Message direction: single, both cfg.gnn.msg_direction = 'single' # Whether add message from node itself: none, add, cat cfg.gnn.self_msg = 'concat' # Number of attention heads cfg.gnn.att_heads = 1 # After concat attention heads, add a linear layer cfg.gnn.att_final_linear = False # After concat attention heads, add a linear layer cfg.gnn.att_final_linear_bn = False # Normalize after message passing cfg.gnn.l2norm = True # randomly use fewer edges for message passing cfg.gnn.keep_edge = 0.5 # clear cached feature_new cfg.gnn.clear_feature = True # ----------------------------------------------------------------------- # # Optimizer options # ----------------------------------------------------------------------- # cfg.optim = CN() # optimizer: sgd, adam cfg.optim.optimizer = 'adam' # Base learning rate cfg.optim.base_lr = 0.01 # L2 regularization cfg.optim.weight_decay = 5e-4 # SGD momentum cfg.optim.momentum = 0.9 # scheduler: none, steps, cos cfg.optim.scheduler = 'cos' # Steps for 'steps' policy (in epochs) cfg.optim.steps = [30, 60, 90] # Learning rate multiplier for 'steps' policy cfg.optim.lr_decay = 0.1 # Maximal number of epochs cfg.optim.max_epoch = 200 # ----------------------------------------------------------------------- # # Batch norm options # ----------------------------------------------------------------------- # cfg.bn = CN() # BN epsilon cfg.bn.eps = 1e-5 # BN momentum (BN momentum in PyTorch = 1 - BN momentum in Caffe2) cfg.bn.mom = 0.1 # ----------------------------------------------------------------------- # # Memory options # ----------------------------------------------------------------------- # cfg.mem = CN() # Perform ReLU inplace cfg.mem.inplace = False # Set user customized cfgs for func in register.config_dict.values(): func(cfg)
from __future__ import absolute_import from __future__ import division from __future__ import print_function import os from yacs.config import CfgNode as CN _C = CN() _C.OUTPUT_DIR = '' _C.LOG_DIR = '' _C.EXPERIMENT_NAME = '' _C.DATA_DIR = '' _C.GPUS = [0, 1, 2, 3] _C.WORKERS = 4 _C.PRINT_FREQ = 20 _C.PIN_MEMORY = True _C.RANK = 0 # Cudnn related params _C.CUDNN = CN() _C.CUDNN.BENCHMARK = True _C.CUDNN.DETERMINISTIC = False _C.CUDNN.ENABLED = True # common params for NETWORK _C.MODEL = CN() _C.MODEL.NAME = 'pose_hrnet' _C.MODEL.INIT_WEIGHTS = True _C.MODEL.PRETRAINED = ''
from __future__ import absolute_import from __future__ import division from __future__ import print_function from yacs.config import CfgNode as CN # pose_resnet related params POSE_RESNET = CN() POSE_RESNET.NUM_LAYERS = 50 POSE_RESNET.DECONV_WITH_BIAS = False POSE_RESNET.NUM_DECONV_LAYERS = 3 POSE_RESNET.NUM_DECONV_FILTERS = [256, 256, 256] POSE_RESNET.NUM_DECONV_KERNELS = [4, 4, 4] POSE_RESNET.FINAL_CONV_KERNEL = 1 POSE_RESNET.PRETRAINED_LAYERS = ['*'] # pose_multi_resoluton_net related params POSE_HIGH_RESOLUTION_NET = CN() POSE_HIGH_RESOLUTION_NET.PRETRAINED_LAYERS = ['*'] POSE_HIGH_RESOLUTION_NET.STEM_INPLANES = 64 POSE_HIGH_RESOLUTION_NET.FINAL_CONV_KERNEL = 1 POSE_HIGH_RESOLUTION_NET.STAGE2 = CN() POSE_HIGH_RESOLUTION_NET.STAGE2.NUM_MODULES = 1 POSE_HIGH_RESOLUTION_NET.STAGE2.NUM_BRANCHES = 2 POSE_HIGH_RESOLUTION_NET.STAGE2.NUM_BLOCKS = [4, 4] POSE_HIGH_RESOLUTION_NET.STAGE2.NUM_CHANNELS = [32, 64] POSE_HIGH_RESOLUTION_NET.STAGE2.BLOCK = 'BASIC' POSE_HIGH_RESOLUTION_NET.STAGE2.FUSE_METHOD = 'SUM' POSE_HIGH_RESOLUTION_NET.STAGE3 = CN()
from __future__ import absolute_import from __future__ import division from __future__ import print_function import os from yacs.config import CfgNode as CN _C = CN() _C.OUTPUT_DIR = '' _C.LOG_DIR = '' _C.DATA_DIR = '' _C.GPUS = (0, ) _C.WORKERS = 4 _C.PRINT_FREQ = 20 _C.AUTO_RESUME = False _C.PIN_MEMORY = True _C.RANK = 0 # Cudnn related params _C.CUDNN = CN() _C.CUDNN.BENCHMARK = True _C.CUDNN.DETERMINISTIC = False _C.CUDNN.ENABLED = True # common params for NETWORK _C.MODEL = CN() _C.MODEL.NAME = 'pose_hrnet' _C.MODEL.POSE_NAME = 'PoseHighResolutionNet' _C.MODEL.INIT_WEIGHTS = True
from yacs.config import CfgNode as CN _C = CN() # Define output parameters _C.Output = CN() _C.Output.batch_name = "geo-encoding-loss-test-2" _C.Output.checkpoint_trigger = 5 # Define callback parameters _C.Callback = CN() _C.Callback.exists = True _C.Callback.names = ["GeoAutoencoderCallback", "MemoryCallback", "ResetHistoryCallback"] _C.Callback.figwidth = 12 _C.Callback.figheight = 2 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()
# Copyright (c) Facebook, Inc. and its affiliates. # # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. """Configuration file (powered by YACS).""" import os from pycls.utils.io import cache_url from yacs.config import CfgNode as CN # Global config object _C = CN() # Example usage: # from core.config import cfg cfg = _C # ------------------------------------------------------------------------------------ # # Model options # ------------------------------------------------------------------------------------ # _C.MODEL = CN() # Model type _C.MODEL.TYPE = "" # Number of weight layers
import os from yacs.config import CfgNode as CN # ---------------------------------------------------------------------------- # # Define Config Node # ---------------------------------------------------------------------------- # _C = CN() # ---------------------------------------------------------------------------- # # Model Configs # ---------------------------------------------------------------------------- # _C.MODEL = CN() # ---------------------------------------------------------------------------- # # __NN Configs # ---------------------------------------------------------------------------- # _C.MODEL.NN = CN() _C.MODEL.NN.INPUT_LAYER = [{'units': 128, 'activation': 'relu'},] _C.MODEL.NN.HIDDEN_LAYERS = [ {'units': 64, 'activation': 'relu'}, {'units': 32, 'activation': 'relu'}, ] _C.MODEL.NN.OUTPUT_LAYER = [{'activation': 'linear'},] _C.MODEL.NN.DROPOUT = 0.2
from yacs.config import CfgNode as CN cn = CN(new_allowed=True) cn.DATASET = CN(new_allowed=True) cn.DATASET.NAME = 'COCO' cn.DATASET.TFRECORDS = '/media/user/data/coco/TF2-SimpleHumanPose/tfrecords' cn.DATASET.ANNOT = '/media/user/data/coco/annotations/person_keypoints_val2017.json' cn.DATASET.TRAIN_SAMPLES = 149813 cn.DATASET.VAL_SAMPLES = 11004 cn.DATASET.KP_FLIP = [0, 2, 1, 4, 3, 6, 5, 8, 7, 10, 9, 12, 11, 14, 13, 16, 15] cn.DATASET.KP_UPPER = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] cn.DATASET.KP_LOWER = [] cn.DATASET.BGR = False cn.DATASET.NORM = True cn.DATASET.MEANS = [0.485, 0.456, 0.406] # imagenet means RGB cn.DATASET.STDS = [0.229, 0.224, 0.225] cn.DATASET.INPUT_SHAPE = [256, 192, 3] cn.DATASET.OUTPUT_SHAPE = [64, 48, 17] cn.DATASET.SIGMA = 2 * cn.DATASET.OUTPUT_SHAPE[0] / 64 cn.DATASET.FLIP_PROB = 0.5 cn.DATASET.HALF_BODY_PROB = 0. cn.DATASET.HALF_BODY_MIN_KP = 8 cn.DATASET.SCALE_FACTOR = 0.3 cn.DATASET.ROT_PROB = 0.6 cn.DATASET.ROT_FACTOR = 40 cn.DATASET.CACHE = False cn.DATASET.BFLOAT16 = False cn.TRAIN = CN(new_allowed=True) cn.TRAIN.BATCH_SIZE = 64
def get_default_config(): cfg = CN() # model cfg.model = CN() cfg.model.name = 'resnet50' cfg.model.pretrained = True # automatically load pretrained model weights if available cfg.model.load_weights = '' # path to model weights cfg.model.resume = '' # path to checkpoint for resume training # data cfg.data = CN() cfg.data.type = 'image' cfg.data.root = 'reid-data' cfg.data.sources = ['market1501'] cfg.data.targets = ['market1501'] cfg.data.workers = 4 # number of data loading workers cfg.data.split_id = 0 # split index cfg.data.height = 256 # image height cfg.data.width = 128 # image width cfg.data.combineall = False # combine train, query and gallery for training cfg.data.transforms = ['random_flip'] # data augmentation cfg.data.norm_mean = [0.485, 0.456, 0.406] # default is imagenet mean cfg.data.norm_std = [0.229, 0.224, 0.225] # default is imagenet std cfg.data.save_dir = 'log' # path to save log # specific datasets cfg.market1501 = CN() cfg.market1501.use_500k_distractors = False # add 500k distractors to the gallery set for market1501 cfg.cuhk03 = CN() cfg.cuhk03.labeled_images = True # use labeled images, if False, use detected images cfg.cuhk03.classic_split = False # use classic split by Li et al. CVPR14 cfg.cuhk03.use_metric_cuhk03 = False # use cuhk03's metric for evaluation # sampler cfg.sampler = CN() cfg.sampler.train_sampler = 'RandomSampler' cfg.sampler.num_instances = 4 # number of instances per identity for RandomIdentitySampler # video reid setting cfg.video = CN() cfg.video.seq_len = 15 # number of images to sample in a tracklet cfg.video.sample_method = 'evenly' # how to sample images from a tracklet cfg.video.pooling_method = 'avg' # how to pool features over a tracklet # train cfg.train = CN() cfg.train.optim = 'adam' cfg.train.lr = 0.0003 cfg.train.weight_decay = 5e-4 cfg.train.max_epoch = 60 cfg.train.start_epoch = 0 cfg.train.batch_size = 32 cfg.train.fixbase_epoch = 0 # number of epochs to fix base layers cfg.train.open_layers = [ 'classifier' ] # layers for training while keeping others frozen cfg.train.staged_lr = False # set different lr to different layers cfg.train.new_layers = ['classifier'] # newly added layers with default lr cfg.train.base_lr_mult = 0.1 # learning rate multiplier for base layers cfg.train.lr_scheduler = 'single_step' cfg.train.stepsize = [20] # stepsize to decay learning rate cfg.train.gamma = 0.1 # learning rate decay multiplier cfg.train.print_freq = 20 # print frequency cfg.train.seed = 1 # random seed # optimizer cfg.sgd = CN() cfg.sgd.momentum = 0.9 # momentum factor for sgd and rmsprop cfg.sgd.dampening = 0. # dampening for momentum cfg.sgd.nesterov = False # Nesterov momentum cfg.rmsprop = CN() cfg.rmsprop.alpha = 0.99 # smoothing constant cfg.adam = CN() cfg.adam.beta1 = 0.9 # exponential decay rate for first moment cfg.adam.beta2 = 0.999 # exponential decay rate for second moment # loss cfg.loss = CN() cfg.loss.name = 'softmax' cfg.loss.softmax = CN() cfg.loss.softmax.label_smooth = True # use label smoothing regularizer cfg.loss.triplet = CN() cfg.loss.triplet.margin = 0.3 # distance margin cfg.loss.triplet.weight_t = 0.1 # weight to balance hard triplet loss cfg.loss.triplet.weight_x = 1. # weight to balance cross entropy loss # test cfg.test = CN() cfg.test.batch_size = 100 cfg.test.dist_metric = 'euclidean' # distance metric, ['euclidean', 'cosine'] cfg.test.normalize_feature = False # normalize feature vectors before computing distance cfg.test.ranks = [1, 5, 10, 20] # cmc ranks cfg.test.evaluate = False # test only cfg.test.eval_freq = -1 # evaluation frequency (-1 means to only test after training) cfg.test.start_eval = 0 # start to evaluate after a specific epoch cfg.test.rerank = False # use person re-ranking cfg.test.visrank = False # visualize ranked results (only available when cfg.test.evaluate=True) cfg.test.visrank_topk = 10 # top-k ranks to visualize cfg.test.visactmap = False # visualize CNN activation maps return cfg
# ----------------------------------------------------------------------------- # Convention about Training / Test specific parameters # ----------------------------------------------------------------------------- # Whenever an argument can be either used for training or for testing, the # corresponding name will be post-fixed by a _TRAIN for a training parameter, # or _TEST for a test-specific parameter. # For example, the maximum image side during training will be # INPUT.MAX_SIZE_TRAIN, while for testing it will be # INPUT.MAX_SIZE_TEST # ----------------------------------------------------------------------------- # Config definition # ----------------------------------------------------------------------------- _C = CN() _C.MODEL = CN() _C.MODEL.DEVICE = "cuda" _C.MODEL.META_ARCH = "MNISTNet" _C.MODEL.CONFIG = "../configs/mnist_net/mnist_net.json" # If the WEIGHT starts with a catalog://, like :R-50, the code will look for # the path in paths_catalog. Else, it will use it as the specified absolute # path _C.MODEL.WEIGHT = "" # ----------------------------------------------------------------------------- # INPUT # ----------------------------------------------------------------------------- _C.INPUT = CN()
from yacs.config import CfgNode as CN _C = CN() # Output basedir. _C.OUTPUT_DIR = "./tmp" # Note that non-determinism may still be present due to non-deterministic # operator implementations in GPU operator libraries. _C.RNG_SEED = 1 # ---------------------------------------------------------------------------- # # Distributed options # ---------------------------------------------------------------------------- # # Number of GPUs to use (applies to both training and testing). _C.NUM_GPUS = 1 # Number of machine to use for the job. _C.NUM_NODES = 1 # The index of the current machine. _C.RANK_ID = 0 # Distributed backend. _C.DIST_BACKEND = "nccl" # ---------------------------------------------------------------------------- # # Train # ---------------------------------------------------------------------------- # _C.TRAIN = CN()