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()
