def parameters(ID=None):
# Tracker specific parameters
params = TrackerParams()
# Parameters for debugging
params.output_image = False
params.output_image_path = './debug/result_image/'
# Parameters for device and tracking model
params.use_gpu = True
params.device = 'cuda'
params.model = deep.SBDTNet50(net_path='DCFST-50.pth')
# Parameters for sampling search region
params.search_padding = 5.0 # Sampling size relative to target size
params.img_sample_area = 288**2 # Area of the search region image
# Parameters for training locator
params.regularization = 0.1 # Regularization term to train locator (train with 0.1)
params.learning_rate = 0.016 # Learning rate to update locator
params.output_sigma_factor = 1 / 4 # Standard deviation of Gaussian label relative to target size (train with 1/4)
params.proposals_num = 31**2 # Number of uniform proposals in locator (train with 31**2)
params.train_skipping = 10 # How often to run locator training (common: 10)
params.target_not_found = 0.2 # Absolute score threshold to detect target missing (small)
params.init_samples_minimum_weight = 0.25 # Minimum weight of initial samples
# Parameters for hard negative samples mining
params.hard_negative_mining = True # Whether to perform hard negative samples mining
params.hard_negative_threshold = 0.5 # Relative threshold to find hard negative samples (common: 0.5)
params.hard_negative_learning_rate = 0.01 # Learning rate if hard negative samples are detected (small)
params.hard_negative_distance_ratio = 0.75 # Scope to ignore the detection of hard negative samples relative to target size
# Parameters for window
params.window_output = True # Whether to perform window
params.window_sigma_factor = 1.2 # Standard deviation of Gaussian window relative to target size (large)
params.window_min_value = 0.5 # Min value of the output window (large)
# Parameters for iounet refinement
params.num_init_random_boxes = 19 # Number of random boxes for scale refinement (ATOM: 9)
params.box_jitter_pos = 0.2 # How much to jitter the translation for random boxes (ATOM: 0.1)
params.box_jitter_sz = 0.5 # How much to jitter the scale for random boxes (ATOM: 0.5)
params.box_refinement_iter = 5 # Number of iterations for box refinement (ATOM: 5)
params.maximal_aspect_ratio = 6 # Limit on the aspect ratio (ATOM: 6)
params.iounet_k = 5 # Top-k average to estimate final box (ATOM: 3)
params.scale_damp = 0.3 # Linear interpolation coefficient for target scale update (small)
# Parameters for data augmentation
params.augmentation = True # Whether to perform data augmentation
params.augmentation_expansion_factor = 2 # How much to expand sample when doing augmentation
params.augmentation_method = {
'fliplr': True,
'rotate': [5, -5, 10, -10, 20, -20],
'blur': [(2, 0.2), (0.2, 2), (3, 1), (1, 3), (2, 2)]
}
return params
def parameters():
params = TrackerParams()
# These are usually set from outside
params.debug = 0 # Debug level
params.visualization = False # Do visualization
# Use GPU or not (IoUNet requires this to be True)
params.use_gpu = True
# Feature specific parameters
deep_params = TrackerParams()
# Patch sampling parameters
params.max_image_sample_size = (18 * 16)**2 # Maximum image sample size
params.min_image_sample_size = (18 * 16)**2 # Minimum image sample size
params.search_area_scale = 5 # Scale relative to target size
params.feature_size_odd = False # Good to use False for even-sized kernels and vice versa
# Optimization parameters
params.CG_iter = 5 # The number of Conjugate Gradient iterations in each update after the first frame
params.init_CG_iter = 60 # The total number of Conjugate Gradient iterations used in the first frame
params.init_GN_iter = 6 # The number of Gauss-Newton iterations used in the first frame (only if the projection matrix is updated)
params.post_init_CG_iter = 0 # CG iterations to run after GN
params.fletcher_reeves = False # Use the Fletcher-Reeves (true) or Polak-Ribiere (false) formula in the Conjugate Gradient
params.standard_alpha = True # Use the standard formula for computing the step length in Conjugate Gradient
params.CG_forgetting_rate = None # Forgetting rate of the last conjugate direction
# Learning parameters for each feature type
deep_params.learning_rate = 0.01 # Learning rate
deep_params.init_samples_minimum_weight = 0.25 # Minimum weight of initial samples in memory
deep_params.output_sigma_factor = 1 / 4 # Standard deviation of Gaussian label relative to target size
# Training parameters
params.sample_memory_size = 250 # Memory size
params.train_skipping = 10 # How often to run training (every n-th frame)
# Online model parameters
deep_params.kernel_size = (4, 4) # Kernel size of filter
deep_params.compressed_dim = 64 # Dimension output of projection matrix
deep_params.filter_reg = 1e-1 # Filter regularization factor
deep_params.projection_reg = 1e-4 # Projection regularization factor
# Windowing
params.feature_window = False # Perform windowing of features
params.window_output = False # Perform windowing of output scores
# Detection parameters
params.scale_factors = torch.ones(
1
) # What scales to use for localization (only one scale if IoUNet is used)
params.score_upsample_factor = 1 # How much Fourier upsampling to use
# Init data augmentation parameters
params.augmentation = {
'fliplr': True,
'rotate': [5, -5, 10, -10, 20, -20, 30, -30, 45, -45, -60, 60],
'blur': [(2, 0.2), (0.2, 2), (3, 1), (1, 3), (2, 2)],
'relativeshift': [(0.6, 0.6), (-0.6, 0.6), (0.6, -0.6), (-0.6, -0.6)],
'dropout': (7, 0.2)
}
params.augmentation_expansion_factor = 2 # How much to expand sample when doing augmentation
params.random_shift_factor = 1 / 3 # How much random shift to do on each augmented sample
deep_params.use_augmentation = True # Whether to use augmentation for this feature
# Factorized convolution parameters
# params.use_projection_matrix = True # Use projection matrix, i.e. use the factorized convolution formulation
params.update_projection_matrix = True # Whether the projection matrix should be optimized or not
params.proj_init_method = 'randn' # Method for initializing the projection matrix
params.filter_init_method = 'randn' # Method for initializing the spatial filter
params.projection_activation = 'none' # Activation function after projection ('none', 'relu', 'elu' or 'mlu')
params.response_activation = (
'mlu', 0.05
) # Activation function on the output scores ('none', 'relu', 'elu' or 'mlu')
# Advanced localization parameters
params.advanced_localization = True # Use this or not
params.target_not_found_threshold = 0.25 # Absolute score threshold to detect target missing
params.distractor_threshold = 0.8 # Relative threshold to find distractors
params.hard_negative_threshold = 0.5 # Relative threshold to find hard negative samples
params.target_neighborhood_scale = 2.2 # Target neighborhood to remove
params.dispalcement_scale = 0.8 # Dispacement to consider for distractors
params.hard_negative_learning_rate = 0.02 # Learning rate if hard negative detected
params.hard_negative_CG_iter = 5 # Number of optimization iterations to use if hard negative detected
params.update_scale_when_uncertain = True # Update scale or not if distractor is close
# IoUNet parameters
params.use_iou_net = True # Use IoU net or not
params.box_refinement_space = 'relative'
params.iounet_augmentation = False # Use the augmented samples to compute the modulation vector
params.iounet_k = 3 # Top-k average to estimate final box
params.num_init_random_boxes = 9 # Num extra random boxes in addition to the classifier prediction
params.box_jitter_pos = 0.1 # How much to jitter the translation for random boxes
params.box_jitter_sz = 0.5 # How much to jitter the scale for random boxes
params.maximal_aspect_ratio = 6 # Limit on the aspect ratio
params.box_refinement_iter = 10 # Number of iterations for refining the boxes
params.box_refinement_step_length = (
1e-2, 5e-2
) # 1 # Gradient step length in the bounding box refinement 5e-3 2e-2
params.box_refinement_step_decay = 1 # Multiplicative step length decay (1 means no decay)
# Setup the feature extractor (which includes the IoUNet)
deep_fparams = FeatureParams(feature_params=[deep_params])
deep_feat = deep.ATOMResNet18(net_path='atom_gmm_sampl',
output_layers=['layer3'],
fparams=deep_fparams,
normalize_power=2)
params.features = MultiResolutionExtractor([deep_feat])
return params
def parameters():
params = TrackerParams()
params.debug = 0
params.visualization = False
params.use_gpu = True
params.image_sample_size = 22 * 16
params.search_area_scale = 6
params.border_mode = 'inside_major'
params.patch_max_scale_change = 1.5
# Learning parameters
params.sample_memory_size = 50
params.learning_rate = 0.01
params.init_samples_minimum_weight = 0.25
params.train_skipping = 20
# Net optimization params
params.update_classifier = True
params.net_opt_iter = 10
params.net_opt_update_iter = 2
params.net_opt_hn_iter = 1
# Detection parameters
params.window_output = False
# Init augmentation parameters
params.use_augmentation = True
params.augmentation = {
'fliplr': True,
'rotate': [10, -10, 45, -45],
'blur': [(3, 1), (1, 3), (2, 2)],
'relativeshift': [(0.6, 0.6), (-0.6, 0.6), (0.6, -0.6), (-0.6, -0.6)],
'dropout': (2, 0.2)
}
params.augmentation_expansion_factor = 2
params.random_shift_factor = 1 / 3
# Advanced localization parameters
params.advanced_localization = True
params.target_not_found_threshold = 0.25
params.distractor_threshold = 0.8
params.hard_negative_threshold = 0.45
params.target_neighborhood_scale = 2.2
params.dispalcement_scale = 0.8
params.hard_negative_learning_rate = 0.02
params.update_scale_when_uncertain = True
# IoUnet parameters
params.box_refinement_space = 'relative'
params.iounet_augmentation = False # Use the augmented samples to compute the modulation vector
params.iounet_k = 3 # Top-k average to estimate final box
params.num_init_random_boxes = 9 # Num extra random boxes in addition to the classifier prediction
params.box_jitter_pos = 0.1 # How much to jitter the translation for random boxes
params.box_jitter_sz = 0.5 # How much to jitter the scale for random boxes
params.maximal_aspect_ratio = 6 # Limit on the aspect ratio
params.box_refinement_iter = 10 # Number of iterations for refining the boxes
params.box_refinement_step_length = 2.5e-3 # 1 # Gradient step length in the bounding box refinement
params.box_refinement_step_decay = 1 # Multiplicative step length decay (1 means no decay)
params.net = NetWithBackbone(net_path='super_dimp.pth.tar',
use_gpu=params.use_gpu)
params.vot_anno_conversion_type = 'preserve_area'
params.perform_hn_without_windowing = False
params.save_sample_interval = 2 # save memory interval
# [------ new parameters -------]
# parameters for re-detection
params.re_detection = True # [default:True] Re-detection
params.flag_confidence = 6 # [default:6] different methods about confidence score
params.cnt_global = 10000 # [default:10000->not use] global search for each count
params.global_search_memory_limit = 200 # global search memory limit
params.cnt_random = 5 # [default:5] random search for each count
params.additional_candidate_random = 3 # [default:3] the number of candidates to search (when additional_candidate_adaptive is False)
params.additional_candidate_adaptive = True # [default:True] adaptive number of candidates to search
params.additional_candidate_adaptive_ratio = 0.1 # [default:0.1] ratio for adaptive number
params.additional_candidate_adaptive_min = 1 # [default:1] minimum number for searching
params.additional_candidate_adaptive_max = 10 # [default:10] maximum number for searching
params.redetection_score_penalty = True # [default:True] score penalty for re-detection
params.redetection_score_penalty_alpha = 0.75 # [default:0.75] score penalty parameter, about distance (big value -> more penalty)
params.redetection_score_penalty_beta = 0.25 # [default:0.25] score penalty parameter, about time (small value -> slow detect)
params.redetection_basic_penalty = 0.75 # [default:0.75] score penalty parameter, total score reduction, (0.75 -> 25% reduce score)
params.redetection_now = True # [default:True] re-detection immediately after tracking failure
params.no_update_early_redetection = 1 # no update period after re-detection success
params.no_save_early_redetection = 0 # no save period after re-detection success
params.redetection_global_search_flag = 1 # search position flag (0: 1/4 overlap, 1: half overlap, 2: none overlap)
# parameters for more discriminative learning
params.init_net_more_learn = True # more discriminative learning (init)
params.init_more_learn_expand_searching_size = True # expanding searching size for more init samples
params.init_more_learn_flag = 1 # search position flag (0: 1/4 overlap, 1: half overlap, 2: none overlap)
params.init_more_learn_memory_limit = 40 # 100 -> 4Gb (smaller than sample_memory_size - 2), default:40
params.init_more_learn_no_transform = True # whether transformation
params.init_more_sample_limit = 10 # searching number limit
params.init_iou_more_learn = True # same as init_net_more_learn, iounet_augmentation = True -> can change
params.track_net_more_learn = True # more discriminative learning (track)
params.track_net_more_learn_search_flag = 2 # search position flag (0: 1/4 overlap, 1: half overlap, 2: none overlap)
params.track_net_more_learn_cnt = 3 # more learning period
params.track_net_more_learn_score = 0.70 # score condition for more learning
params.track_net_more_learn_not_save = True # if True: not save and learn each time (not depend on track_net_more_learn_cnt)
params.track_net_more_learn_save_weight = 0.5 # reduce memory weight (due to not real data)
params.train_more_sample_limit = 10 # searching number limit
params.additional_train_candidate = 2 # number of additional samples
params.memory_weight_ratio = 2 # weight for initial feature (higher -> more important)
params.init_blending = 0.0 # image blending with target and background (0: not blending, 0.1: 10% background, 90% target)
# parameters for random erasing
params.erasing_mode = True # Random erasing (RE) mode when tracking
params.use_original_pos = False # Random erasing flag
params.erasing_cnt = 5 # Random erasing period
params.lower_scale = 0.02 # RE parameters
params.upper_scale = 0.05 # RE parameters
params.lower_ratio = 0.7 # RE parameters
params.upper_ratio = 1.3 # RE parameters
params.num_erasing = 10 # the number of random erasing images
return params
def parameters(ID=None):
# Tracker specific parameters
params = TrackerParams()
# ------------------ CHANGED ------------------#
# Output result images
params.output_image = False
params.output_image_path = './debug/result_image/'
# Training parameters for locator
params.regularization = 0.1 # Regularization term to train locator
params.learning_rate = 0.016 # Learning rate to update locator features model
params.train_skipping = 10 # How often to run training (every n-th frame)
params.output_sigma_factor = 1 / 4 # Standard deviation of Gaussian label relative to target size
params.target_not_found_threshold = 0.25 # Absolute score threshold to detect target missing
params.init_samples_minimum_weight = 0.25 # Minimum weight of initial samples
# Hard negative samples mining
params.hard_negative_mining = True # Perform hard negative samples mining
params.hard_negative_threshold = 0.3 # Absolute threshold to find hard negative samples
params.hard_negative_learning_rate = 0.125 # Learning rate if hard negative samples are detected
params.hard_negative_distance_ratio = 0.15 # Detect hard negative samples range relative to image sample area
# Windowing
params.window_output = True # Perform windowing to output scores
params.window_sigma_factor = 2.2 # Standard deviation of Gaussian output window relative to target size
params.window_min = 0.8 # Min value of the output window
# Scale update
params.scale_damp = 0.3 # Linear interpolation coefficient for target scale update
# Setup the tracking model
params.model = deep.SBDTNet18(net_path='DCFST-18.pth')
# GPU
params.use_gpu = True
params.device = 'cuda'
# Patch sampling
params.search_area_scale = 5 # Scale relative to target size
params.img_sample_area = 288**2 # Area of the image sample
# Locator proposals
params.num_proposals_locator = 31**2 # Number of proposals in locator
# Data augmentation
params.augmentation = {
'fliplr': True,
'rotate': [5, -5, 10, -10, 20, -20],
'blur': [(2, 0.2), (0.2, 2), (3, 1), (1, 3), (2, 2)]
}
params.augmentation_expansion_factor = 2 # How much to expand sample when doing augmentation
params.use_augmentation = True # Whether to use augmentation
# IoUNet
params.iounet_k = 3 # Top-k average to estimate final box
params.num_init_random_boxes = 9 # Num extra random boxes in addition to the classifier prediction
params.box_jitter_pos = 0.1 # How much to jitter the translation for random boxes
params.box_jitter_sz = 0.5 # How much to jitter the scale for random boxes
params.maximal_aspect_ratio = 6 # Limit on the aspect ratio
params.box_refinement_iter = 5 # Number of iterations for refining the boxes
params.box_refinement_step_length = 1 # Gradient step length in the bounding box refinement
params.box_refinement_step_decay = 1 # Multiplicative step length decay (1 means no decay)
# Scale bounds
params.min_scale_factor = 0.2 # Min value of the scale bound
params.max_scale_factor = 5.0 # Max value of the scale bound
return params
def parameters():
params = TrackerParams()
params.debug = 0
params.visualization = False
params.use_gpu = True
params.image_sample_size = 14 * 16
params.search_area_scale = 4
# Learning parameters
params.sample_memory_size = 250
params.learning_rate = 0.0075
params.init_samples_minimum_weight = 0.0
params.train_skipping = 10
# Net optimization params
params.update_classifier = True
params.net_opt_iter = 25
params.net_opt_update_iter = 3
params.net_opt_hn_iter = 3
# Detection parameters
params.window_output = True
# Init augmentation parameters
params.use_augmentation = True
params.augmentation = {
'fliplr': True,
'rotate': [5, -5, 10, -10, 20, -20, 30, -30, 45, -45, -60, 60],
'blur': [(2, 0.2), (0.2, 2), (3, 1), (1, 3), (2, 2)],
'relativeshift': [(0.6, 0.6), (-0.6, 0.6), (0.6, -0.6), (-0.6, -0.6)],
'dropout': (7, 0.2)
}
params.augmentation_expansion_factor = 2
params.random_shift_factor = 1 / 3
# Advanced localization parameters
params.advanced_localization = True
params.target_not_found_threshold = 0.0
params.distractor_threshold = 100
params.hard_negative_threshold = 0.45
params.target_neighborhood_scale = 2.2
params.dispalcement_scale = 0.7
params.perform_hn_without_windowing = True
params.hard_negative_learning_rate = 0.02
params.update_scale_when_uncertain = True
# IoUnet parameters
params.iounet_augmentation = False
params.iounet_use_log_scale = True
params.iounet_k = 3
params.num_init_random_boxes = 9
params.box_jitter_pos = 0.1
params.box_jitter_sz = 0.5
params.maximal_aspect_ratio = 6
params.box_refinement_iter = 5
params.box_refinement_step_length = 1
params.box_refinement_step_decay = 1
params.net = NetWithBackbone(net_path='dimp50.pth', use_gpu=params.use_gpu)
params.vot_anno_conversion_type = 'preserve_area'
params.use_depth_channel = True
return params
def parameters():
params = TrackerParams()
params.debug = 0
params.visualization = False
params.use_gpu = True
params.image_sample_size = 18 * 16
params.search_area_scale = 5
# Learning parameters
params.sample_memory_size = 50
params.learning_rate = 0.01
params.init_samples_minimum_weight = 0.25
params.train_skipping = 20
# Net optimization params
params.update_classifier = True
params.net_opt_iter = 10
params.net_opt_update_iter = 2
params.net_opt_hn_iter = 1
# Detection parameters
params.window_output = False
# Init augmentation parameters
params.use_augmentation = True
params.augmentation = {
'fliplr': True,
'rotate': [10, -10, 45, -45],
'blur': [(3, 1), (1, 3), (2, 2)],
'relativeshift': [(0.6, 0.6), (-0.6, 0.6), (0.6, -0.6), (-0.6, -0.6)],
'dropout': (2, 0.2)
}
params.augmentation_expansion_factor = 2
params.random_shift_factor = 1 / 3
# Advanced localization parameters
params.advanced_localization = True
params.target_not_found_threshold = 0.25
params.distractor_threshold = 0.8
params.hard_negative_threshold = 0.5
params.target_neighborhood_scale = 2.2
params.dispalcement_scale = 0.8
params.hard_negative_learning_rate = 0.02
params.update_scale_when_uncertain = True
# IoUnet parameters
params.iounet_augmentation = False
params.iounet_use_log_scale = True
params.iounet_k = 3
params.num_init_random_boxes = 9
params.box_jitter_pos = 0.1
params.box_jitter_sz = 0.5
params.maximal_aspect_ratio = 6
params.box_refinement_iter = 5
params.box_refinement_step_length = 1
params.box_refinement_step_decay = 1
# params.net = NetWithBackbone(net_path='/home/sgn/Data1/yan/pytracking-models/checkpoints/ltr/dimp/dimp50_RGB/dimp50.pth',
# use_gpu=params.use_gpu)
# params.net = NetWithBackbone(net_path='/home/sgn/Data1/yan/pytracking-models/checkpoints/ltr/dimp/dimp50_DepthInputs_sigmoid/DiMPnet_ep0050.pth.tar',
# use_gpu=params.use_gpu)
params.net = NetWithBackbone(
net_path=
'/home/sgn/Data1/yan/pytracking-models/checkpoints/ltr/dimp/dimp50_D_CDTB_finetune_generated_PP_new02/DiMPnet_ep0150.pth.tar',
use_gpu=params.use_gpu)
# params.net = NetWithBackbone(net_path='/home/sgn/Data1/yan/pytracking-models/checkpoints/ltr/dimp/dimp50_DepthInputs_scratch_LaSOT_COCO/DiMPnet_ep0050.pth.tar',
# use_gpu=params.use_gpu)
# params.net = NetWithBackbone(net_path='/home/sgn/Data1/yan/pytracking-models/checkpoints/ltr/dimp/DOT50_Colormap_LaSOT_COCO_PretrainedDiMP_scratch/DiMPnet_ep0100.pth.tar',
# use_gpu=params.use_gpu)
# params.net = NetWithBackbone(net_path='/home/sgn/Data1/yan/pytracking-models/checkpoints/ltr/dimp/DOT50_Colormap_LaSOT_COCO_Got10k_scratch_PretrainedBackbone/DiMPnet_ep0050.pth.tar',
# use_gpu=params.use_gpu)
params.vot_anno_conversion_type = 'preserve_area'
return params
def parameters():
params = TrackerParams()
params.debug = 0
params.visualization = False
params.use_gpu = True
params.use_classifier = True
params.image_sample_size = 18 * 16
params.search_area_scale = 4.5
params.sample_memory_size = 50
params.learning_rate = 0.01
params.init_samples_minimum_weight = 0.25
params.train_skipping = 20
params.init_train_frames = 5
params.update_classifier_and_regressor = True
params.ues_select_sample_strategy = True
# classifier-18
params.init_train_iter = 6
params.net_opt_iter = 5
params.net_opt_update_iter = 1
params.net_opt_hn_iter = 1
# classifier-72
params.init_train_iter_72 = 6
params.net_opt_iter_72 = 5
params.net_opt_update_iter_72 = 1
params.net_opt_hn_iter_72 = 1
# regressor
params.reg_init_train_iter = 6
params.reg_net_opt_iter = 4
params.reg_net_opt_hn_iter = 0
params.reg_net_opt_update_iter = 1
params.lamda_72 = 1
params.lamda_18 = 1
params.reg_lamda = 0
params.merge_rate_72 = 0.2
params.merge_rate_18 = 0.8
params.use_augmentation = True
params.augmentation = {
'fliplr': True,
'rotate': [5, -5, 10, -10, 20, -20, 30, -30, 45, -45, -60, 60],
'blur': [(2, 0.2), (0.2, 2), (3, 1), (1, 3), (2, 2)],
'relativeshift': [(0.6, 0.6), (-0.6, 0.6), (0.6, -0.6), (-0.6, -0.6)],
# 'dropout': (7, 0.2)
}
params.augmentation_expansion_factor = 2
params.random_shift_factor = 1 / 3
# Advanced localization parameters
params.advanced_localization = True
params.target_not_found_threshold = 0.12
params.distractor_threshold = 0.9
params.hard_negative_threshold = 0.5
params.target_neighborhood_scale = 2.2
params.dispalcement_scale = 0.8
params.window_output = False
params.perform_hn_without_windowing = True
params.hard_negative_learning_rate = 0.02
params.update_scale_when_uncertain = True
params.iou_select = False
params.net = NetWithBackbone(net_path='fcot.pth', use_gpu=params.use_gpu)
params.net.initialize()
params.vot_anno_conversion_type = 'preserve_area'
return params
def parameters(pth_path = None):
params = TrackerParams()
# These are usually set from outside
params.debug = 1 # Debug level
params.visualization = True # Do visualization
# Use GPU or not (IoUNet requires this to be True)
params.use_gpu = True
# Feature specific parameters
deep_params = TrackerParams()
# Patch sampling parameters
params.max_image_sample_size = (16 * 16) ** 2 # (18 * 16) ** 2 # Maximum image sample size
params.min_image_sample_size = (16 * 16) ** 2 # (18 * 16) ** 2 # Minimum image sample size
params.search_area_scale = 4.5 # Scale relative to target size
params.feature_size_odd = False # Good to use False for even-sized kernels and vice versa
# Optimization parameters
params.CG_iter = 5 # The number of Conjugate Gradient iterations in each update after the first frame
params.init_CG_iter = 60 # The total number of Conjugate Gradient iterations used in the first frame
params.init_GN_iter = 6 # The number of Gauss-Newton iterations used in the first frame (only if the projection matrix is updated)
params.post_init_CG_iter = 0 # CG iterations to run after GN
params.fletcher_reeves = False # Use the Fletcher-Reeves (true) or Polak-Ribiere (false) formula in the Conjugate Gradient
params.standard_alpha = True # Use the standard formula for computing the step length in Conjugate Gradient
params.CG_forgetting_rate = None # Forgetting rate of the last conjugate direction
# Learning parameters for each feature type
deep_params.learning_rate = 0.0075 # Learning rate
deep_params.output_sigma_factor = 1/4 # Standard deviation of Gaussian label relative to target size
# Training parameters
params.sample_memory_size = 250 # Memory size
params.train_skipping = 10 # How often to run training (every n-th frame)
# Online model parameters
deep_params.kernel_size = (4, 4) # Kernel size of filter
deep_params.compressed_dim = 64 # Dimension output of projection matrix
deep_params.filter_reg = 1e-1 # Filter regularization factor
deep_params.projection_reg = 1e-4 # Projection regularization factor
# Windowing
params.feature_window = False # Perform windowing of features
params.window_output = True # Perform windowing of output scores
# Detection parameters
params.scale_factors = torch.ones(1) # What scales to use for localization (only one scale if IoUNet is used)
params.score_upsample_factor = 1 # How much Fourier upsampling to use
# Init data augmentation parameters
params.augmentation = {'fliplr': True,
'rotate': [5, -5, 10, -10, 20, -20, 30, -30, 45,-45, -60, 60],
'blur': [(2, 0.2), (0.2, 2), (3,1), (1, 3), (2, 2)],
'relativeshift': [(0.25, 0.25), (-0.25, 0.25), (0.25, -0.25), (-0.25, -0.25), (0.75, 0.75), (-0.75, 0.75), (0.75, -0.75), (-0.75, -0.75)]}
params.augmentation_expansion_factor = 2 # How much to expand sample when doing augmentation
params.random_shift_factor = 0#1 / 3 # How much random shift to do on each augmented sample
deep_params.use_augmentation = True # Whether to use augmentation for this feature
# Factorized convolution parameters
# params.use_projection_matrix = True # Use projection matrix, i.e. use the factorized convolution formulation
params.update_projection_matrix = True # Whether the projection matrix should be optimized or not
params.proj_init_method = 'pca' # Method for initializing the projection matrix randn | pca
params.filter_init_method = 'zeros' # Method for initializing the spatial filter randn | zeros
params.projection_activation = 'none' # Activation function after projection ('none', 'relu', 'elu' or 'mlu')
params.response_activation = ('mlu', 0.05) # Activation function on the output scores ('none', 'relu', 'elu' or 'mlu')
# Advanced localization parameters
params.advanced_localization = True # Use this or not
params.target_not_found_threshold = -1 # Absolute score threshold to detect target missing
params.distractor_threshold = 100 # Relative threshold to find distractors
params.hard_negative_threshold = 0.3 # Relative threshold to find hard negative samples
params.target_neighborhood_scale = 2.2 # Target neighborhood to remove
params.dispalcement_scale = 0.7 # Dispacement to consider for distractors
params.hard_negative_learning_rate = 0.02 # Learning rate if hard negative detected
params.hard_negative_CG_iter = 5 # Number of optimization iterations to use if hard negative detected
params.update_scale_when_uncertain = True # Update scale or not if distractor is close
# Setup the feature extractor (which includes the IoUNet)
deep_fparams = FeatureParams(feature_params=[deep_params])
# use ResNet50 for filter
params.use_resnet50 = True
if params.use_resnet50:
deep_feat_filter = deep.ATOMResNet50(output_layers=['layer3'], fparams=deep_fparams, normalize_power=2)
# deep_feat2 = deep.DRNetSE50(net_path='SE_Res50.pth', output_layers=['layer3'], fparams=deep_fparams, normalize_power=2)
params.features_filter = MultiResolutionExtractor([deep_feat_filter])
#params.features_filter = MultiResolutionExtractor([deep_feat2])
params.vot_anno_conversion_type = 'preserve_area'
params.use_segmentation = True
env = env_settings()
net_path = env.network_path
if pth_path is None:
pth_path = '/home/jaffe/PycharmProjects//DMB/pytracking/networks/recurrent25.pth.tar'
params.pth_path = pth_path
params.segm_use_dist = True
params.segm_normalize_mean = [0.485, 0.456, 0.406]
params.segm_normalize_std = [0.229, 0.224, 0.225]
params.segm_search_area_factor = 4.0
params.segm_feature_sz = 24
params.segm_output_sz = params.segm_feature_sz * 16
params.segm_scale_estimation = True
params.segm_optimize_polygon = True
params.tracking_uncertainty_thr = 3
params.response_budget_sz = 25
params.uncertainty_segm_scale_thr = 3.5
params.uncertainty_segment_thr = 10
params.segm_pixels_ratio = 2
params.mask_pixels_budget_sz = 25
params.segm_min_scale = 0.2
params.max_rel_scale_ch_thr = 0.75
params.consider_segm_pixels_ratio = 1
params.opt_poly_overlap_thr = 0.3
params.poly_cost_a = 1.2
params.poly_cost_b = 1
params.segm_dist_map_type = 'center' # center | bbox
params.min_scale_change_factor = 0.95
params.max_scale_change_factor = 1.05
params.init_segm_mask_thr = 0.5
params.segm_mask_thr = 0.5
params.masks_save_path = ''
# params.masks_save_path = 'save-masks-path'
params.save_mask = False
if params.masks_save_path != '':
params.save_mask = True
return params
def parameters():
params = TrackerParams()
params.debug = 0
params.visualization = False
params.use_gpu = True
params.image_sample_size = 14*16
params.search_area_scale = 4
params.border_mode = 'inside_major'
params.patch_max_scale_change = 1.5
# Learning parameters
params.sample_memory_size = 250
params.learning_rate = 0.0075
params.init_samples_minimum_weight = 0.0
params.train_skipping = 10
# Net optimization params
params.update_classifier = True
params.net_opt_iter = 25
params.net_opt_update_iter = 3
params.net_opt_hn_iter = 3
# Detection parameters
params.window_output = True
# Init augmentation parameters
params.use_augmentation = True
params.augmentation = {'fliplr': True,
'rotate': [-5, 10, -30, 60],
'blur': [(2, 0.2), (1, 3)],
'relativeshift': [(0.6, 0.6), (-0.6, -0.6)],
'dropout': (3, 0.2)}
params.augmentation_expansion_factor = 2
params.random_shift_factor = 1/3
# Advanced localization parameters
params.advanced_localization = True
params.target_not_found_threshold = 0.0
params.distractor_threshold = 100
params.hard_negative_threshold = 0.45
params.target_neighborhood_scale = 2.2
params.dispalcement_scale = 0.7
params.perform_hn_without_windowing = True
params.hard_negative_learning_rate = 0.02
params.update_scale_when_uncertain = True
# IoUnet parameters
params.box_refinement_space = 'relative'
params.iounet_augmentation = False # Use the augmented samples to compute the modulation vector
params.iounet_k = 3 # Top-k average to estimate final box
params.num_init_random_boxes = 9 # Num extra random boxes in addition to the classifier prediction
params.box_jitter_pos = 0.1 # How much to jitter the translation for random boxes
params.box_jitter_sz = 0.5 # How much to jitter the scale for random boxes
params.maximal_aspect_ratio = 6 # Limit on the aspect ratio
params.box_refinement_iter = 10 # Number of iterations for refining the boxes
params.box_refinement_step_length = 2.5e-3 # 1 # Gradient step length in the bounding box refinement
params.box_refinement_step_decay = 1 # Multiplicative step length decay (1 means no decay)
params.net = NetWithBackbone(net_path='trdimp_net.pth.tar', use_gpu=params.use_gpu)
params.vot_anno_conversion_type = 'preserve_area'
return params
def parameters():
params = TrackerParams()
params.debug = 0
params.visualization = False
params.use_gpu = True
deep_params = TrackerParams()
params.image_sample_size = 14 * 16
params.search_area_scale = 4
params.feature_size_odd = False
# Learning parameters
params.sample_memory_size = 250
deep_params.learning_rate = 0.0075
deep_params.init_samples_minimum_weight = 0.0
params.train_skipping = 10
deep_params.output_sigma_factor = 1 / 4
# Net optimization params
params.update_classifier = True
params.net_opt_iter = 25
params.net_opt_update_iter = 3
params.net_opt_hn_iter = 3
params.scale_factors = torch.ones(1)
# Spatial filter parameters
deep_params.kernel_size = (4, 4)
params.window_output = True
# Detection parameters
# params.score_upsample_factor = 1
# params.score_fusion_strategy = 'weightedsum'
# deep_params.translation_weight = 1
# Init augmentation parameters
# params.augmentation = {}
params.augmentation = {
'fliplr': True,
'rotate': [5, -5, 10, -10, 20, -20, 30, -30, 45, -45, -60, 60],
'blur': [(2, 0.2), (0.2, 2), (3, 1), (1, 3), (2, 2)],
'relativeshift': [(0.6, 0.6), (-0.6, 0.6), (0.6, -0.6), (-0.6, -0.6)],
'dropout': (7, 0.2)
}
params.augmentation_expansion_factor = 2
params.random_shift_factor = 1 / 3
deep_params.use_augmentation = True
# Advanced localization parameters
params.advanced_localization = True
params.target_not_found_threshold = 0.0
params.distractor_threshold = 100
params.hard_negative_threshold = 0.3
params.target_neighborhood_scale = 2.2
params.dispalcement_scale = 0.7
params.perform_hn_without_windowing = True
params.hard_negative_learning_rate = 0.02
params.update_scale_when_uncertain = True
# IoUnet parameters
params.iounet_augmentation = False
params.iounet_use_log_scale = True
params.iounet_k = 3
params.num_init_random_boxes = 9
params.box_jitter_pos = 0.1
params.box_jitter_sz = 0.5
params.maximal_aspect_ratio = 6
params.box_refinement_iter = 5
params.box_refinement_step_length = 1
params.box_refinement_step_decay = 1
deep_fparams = FeatureParams(feature_params=[deep_params])
deep_feat = trackernet.SimpleTrackerResNet18(
net_path='sdlearn_300_onlytestloss_lr_causal_mg30_iou_coco',
fparams=deep_fparams)
params.features = MultiResolutionExtractor([deep_feat])
params.vot_anno_conversion_type = 'preserve_area'
return params
def parameters():
params = TrackerParams()
params.debug = 0
params.visualization = False
params.use_gpu = True
params.image_sample_size = 18 * 16 #18*16
params.search_area_scale = 5
# Learning parameters
params.sample_memory_size = 250
params.learning_rate = 0.01
params.init_samples_minimum_weight = 0.25
params.train_skipping = 10
# Net optimization params
params.update_classifier = True
params.net_opt_iter = 10 #10
params.net_opt_update_iter = 2
params.net_opt_hn_iter = 1
params.update_classifier_initial = 5
params.update_classifier_initial_iter = 1
# Detection parameters
params.window_output = False
# Init augmentation parameters
params.use_augmentation = True
# params.augmentation = {'fliplr': True,
# 'rotate': [10, -10, 45, -45],
# 'blur': [(3,1), (1, 3), (2, 2)],
# 'relativeshift': [(0.6, 0.6), (-0.6, 0.6), (0.6, -0.6), (-0.6,-0.6)],
# 'dropout': (2, 0.2)}
params.augmentation = {
'fliplr': True,
'rotate': [5, -5, 10, -10, 20, -20, 30, -30, 45, -45, -60, 60],
'blur': [(2, 0.2), (0.2, 2), (3, 1), (1, 3), (2, 2)],
'relativeshift': [(0.6, 0.6), (-0.6, 0.6), (0.6, -0.6), (-0.6, -0.6)],
'dropout': (7, 0.2)
}
params.augmentation_expansion_factor = 2
params.random_shift_factor = 1 / 3
# Advanced localization parameters
params.advanced_localization = True
params.target_not_found_threshold = 0.25
params.distractor_threshold = 0.8 #0.8
params.hard_negative_threshold = 0.5 #0.5
params.target_neighborhood_scale = 2.2
params.dispalcement_scale = 0.8
params.hard_negative_learning_rate = 0.02
params.update_scale_when_uncertain = True
#redetection parameters
params.num_history = 3
params.target_refound_threshold = params.target_not_found_threshold
params.target_forcerefound_threshold = params.target_not_found_threshold + 0.03 #recover from redtection model, even the valid_d is false
params.threshold_updatedepth = params.target_not_found_threshold + 0.05
params.frames_true_validd = 0
params.threshold_force_redetection = params.target_not_found_threshold - 0.05
params.threshold_allowupdateclassifer = params.target_not_found_threshold + 0.05
# IoUnet parameters
params.iounet_augmentation = False
params.iounet_use_log_scale = True
params.iounet_k = 3
params.num_init_random_boxes = 9
params.box_jitter_pos = 0.1
params.box_jitter_sz = 0.5
params.maximal_aspect_ratio = 6
params.box_refinement_iter = 5
params.box_refinement_step_length = 1
params.box_refinement_step_decay = 1
params.rotate_init_random_boxes = False
params.net = NetWithBackbone(net_path='dimp50.pth', use_gpu=params.use_gpu)
params.vot_anno_conversion_type = 'preserve_area'
#depth parameters
params.use_depth_channel = True
params.ptb_setting = True
params.votd_setting = False
params.stc_setting = False
params.threshold_bhatta = 0.2
return params
def parameters():
params = TrackerParams()
params.debug = 0
params.visualization = False
params.use_gpu = True
params.image_sample_size = 14*16
params.search_area_scale = 4
# Learning parameters
params.sample_memory_size = 250
params.learning_rate = 0.0075
params.init_samples_minimum_weight = 0.0
params.train_skipping = 10
# Net optimization params
params.update_classifier = True
params.net_opt_iter = 25
params.net_opt_update_iter = 3
params.net_opt_hn_iter = 3
params.output_sigma_factor = 1/4
# Init augmentation parameters
params.use_augmentation = True
params.augmentation = {'fliplr': True,
'rotate': [5, -5, 10, -10, 20, -20, 30, -30, 45, -45, -60, 60],
'blur': [(2, 0.2), (0.2, 2), (3, 1), (1, 3), (2, 2)],
'relativeshift': [(0.6, 0.6), (-0.6, 0.6), (0.6, -0.6), (-0.6, -0.6)],
'dropout': (7, 0.2)}
params.augmentation_expansion_factor = 2
params.random_shift_factor = 1 / 3
# localization parameters
params.window_output = True
params.use_clipped_window = True
params.effective_search_area = 4.0
params.apply_window_to_dimp_score = True
params.target_not_found_threshold_fused = 0.05
params.dimp_threshold = 0.05
params.reset_state_during_occlusion = True
params.prev_feat_remove_subpixel_shift = True
params.move_feat_to_center = True
params.perform_hn_mining_dimp = True
params.hard_negative_threshold = 0.5
params.target_neighborhood_scale_safe = 2.2
params.hard_negative_learning_rate = 0.02
params.update_scale_when_uncertain = True
# IoUnet parameters
params.use_iou_net = True
params.iounet_augmentation = False
params.iounet_use_log_scale = True
params.iounet_k = 3
params.num_init_random_boxes = 9
params.box_jitter_pos = 0.1
params.box_jitter_sz = 0.5
params.maximal_aspect_ratio = 6
params.box_refinement_iter = 5
params.box_refinement_step_length = 1
params.box_refinement_step_decay = 1
params.remove_offset_in_fused_score = True
params.score_downsample_factor = 1
params.net = NetWithBackbone(net_path='kys.pth',
use_gpu=params.use_gpu)
params.vot_anno_conversion_type = 'preserve_area'
return params
def parameters():
params = TrackerParams()
# These are usually set from outside
params.debug = 0 # Debug level
params.visualization = False # Do visualization
# Use GPU or not (IoUNet requires this to be True)
params.use_gpu = True
# Feature specific parameters
deep_params = TrackerParams()
# Patch sampling parameters
params.max_image_sample_size = (320)**2 # Maximum image sample size
params.min_image_sample_size = (320)**2 # Minimum image sample size
params.search_area_scale = 5.5 # Scale relative to target size
params.feature_size_odd = False # Good to use False for even-sized kernels and vice versa
# Optimization parameters
params.CG_iter = 5 # The number of Conjugate Gradient iterations in each update after the first frame
params.init_CG_iter = 100 # The total number of Conjugate Gradient iterations used in the first frame
params.init_GN_iter = 10 # The number of Gauss-Newton iterations used in the first frame (only if the projection matrix is updated)
params.post_init_CG_iter = 0 # CG iterations to run after GN
params.fletcher_reeves = False # Use the Fletcher-Reeves (true) or Polak-Ribiere (false) formula in the Conjugate Gradient
params.standard_alpha = True # Use the standard formula for computing the step length in Conjugate Gradient
params.CG_forgetting_rate = None # Forgetting rate of the last conjugate direction
# Learning parameters for each feature type
deep_params.learning_rate = 0.0075 # Learning rate
deep_params.output_sigma_factor = [
1 / 3, 1 / 4
] # Standard deviation of Gaussian label relative to target size
# Training parameters
params.sample_memory_size = 250 # Memory size
params.train_skipping = 10 # How often to run training (every n-th frame)
# Online model parameters
deep_params.kernel_size = [(4, 4), (4, 4)] # Kernel size of filter
deep_params.compressed_dim = [32,
32] # Dimension output of projection matrix
deep_params.filter_reg = 1e-1 # Filter regularization factor
deep_params.projection_reg = 1e-4 # Projection regularization factor
# Windowing
params.feature_window = False # Perform windowing of features
params.window_output = True # Perform windowing of output scores
# Detection parameters
params.scale_factors = torch.ones(
1
) # What scales to use for localization (only one scale if IoUNet is used)
params.score_upsample_factor = 1 # How much Fourier upsampling to use
# Init data augmentation parameters
params.augmentation = {
'fliplr': True,
'rotate': [5, -5, 10, -10, 20, -20, 30, -30, 45, -45, -60, 60],
'blur': [(2, 0.2), (0.2, 2), (3, 1), (1, 3), (2, 2)],
'relativeshift': [(0.6, 0.6), (-0.6, 0.6), (0.6, -0.6), (-0.6, -0.6)],
'dropout': (7, 0.2)
}
params.augmentation_expansion_factor = 2 # How much to expand sample when doing augmentation
params.random_shift_factor = 1 / 3 # How much random shift to do on each augmented sample
deep_params.use_augmentation = True # Whether to use augmentation for this feature
# Factorized convolution parameters
# params.use_projection_matrix = True # Use projection matrix, i.e. use the factorized convolution formulation
params.update_projection_matrix = True # Whether the projection matrix should be optimized or not
params.proj_init_method = 'randn' # Method for initializing the projection matrix
params.filter_init_method = 'randn' # Method for initializing the spatial filter
params.projection_activation = 'none' # Activation function after projection ('none', 'relu', 'elu' or 'mlu')
params.response_activation = (
'mlu', 0.05
) # Activation function on the output scores ('none', 'relu', 'elu' or 'mlu')
# Advanced localization parameters
params.advanced_localization = True # Use this or not
params.target_not_found_threshold = -1 # Absolute score threshold to detect target missing
params.distractor_threshold = 100 # Relative threshold to find distractors
params.hard_negative_threshold = 0.3 # Relative threshold to find hard negative samples
params.target_neighborhood_scale = 2.2 # Target neighborhood to remove
params.dispalcement_scale = 0.9 # Dispacement to consider for distractors
params.hard_negative_learning_rate = 0.0075 # Learning rate if hard negative detected
params.hard_negative_CG_iter = 5 # Number of optimization iterations to use if hard negative detected
params.update_scale_when_uncertain = True # Update scale or not if distractor is close
params.alpha = 0
params.beta = -1
# Setup the feature extractor (which includes the IoUNet)i ATOMnet_ep0026.pth
deep_fparams = FeatureParams(feature_params=[deep_params])
deep_feat = deep.DRNetMobileNetSmall(net_path='drnet_cfkd.pth.tar',
output_layers=['layer3'],
fparams=deep_fparams,
normalize_power=2)
params.features = MultiResolutionExtractor([deep_feat])
params.vot_anno_conversion_type = 'preserve_area'
return params
def parameters():
params = TrackerParams()
# ++++++++++++++++++++++++++++ Parallel SiamMask +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
params.use_parallel_smask = True
params.use_area_preserve = True
params.parallel_smask_iou_threshold = 0.7
params.parallel_smask_area_preserve_threshold = 2
params.parallel_smask_config = osp.join(ROOT_DIR,
'pytracking/tracker/siamesemask/experiments/siammask/config_vot.json')
params.parallel_smask_ckpt = osp.join(ROOT_DIR, 'pytracking/networks/SiamMask_VOT_LD.pth')
params.use_smask_replace_atom = True
# ++++++++++++++++++++++++++++ Sequential SiamMask +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
params.use_sequential_smask = True
params.sequential_smask_ratio = 0.25
params.sequential_smask_config = osp.join(ROOT_DIR,
'pytracking/tracker/siamesemask_127/experiments/siammask/config_vot.json')
params.sequential_smask_ckpt = osp.join(ROOT_DIR, 'pytracking/networks/SiamMask_VOT_LD.pth')
# ++++++++++++++++++++++++++++ Refine ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
params.is_refine = False # use optimization algorithm to optimize mask
params.is_fast_refine = False
params.is_faster_refine = True
params.angle_state = False
params.soft_angle_state = False
# ++++++++++++++++++++++++++++ ATOM PARAMS +++++++++++++++++++++++++++++++++++++++++++++++++++++
# Patch sampling parameters using area ratio
params.use_adaptive_maximal_aspect_ratio = True
params.use_area_ratio_adaptive_search_region = True
params.area_ratio_adaptive_ratio = 0.005
params.use_area_ratio_prevent_zoom_in = True
params.area_ratio_zoom_in_ratio = 0.75
params.feature_size_odd = False
# Patch sampling parameters using current and mean max response speed
params.use_speed_adaptive_search_region = True
params.current_speed_threshold = 0.25
params.mean_speed_threshold = 0.20
params.center_distance_threshold = 0.3
# These are usually set from outside
params.debug = 0 # Debug level
params.visualization = False # Do visualization
# Use GPU or not (IoUNet requires this to be True)
params.use_gpu = True
# Feature specific parameters
deep_params = TrackerParams()
# Optimization parameters
params.CG_iter = 8 # The number of Conjugate Gradient iterations in each update after the first frame
params.init_CG_iter = 60 # The total number of Conjugate Gradient iterations used in the first frame
params.init_GN_iter = 6 # The number of Gauss-Newton iterations used in the first frame (only if the projection matrix is updated)
params.post_init_CG_iter = 0 # CG iterations to run after GN
params.fletcher_reeves = False # Use the Fletcher-Reeves (true) or Polak-Ribiere (false) formula in the Conjugate Gradient
params.standard_alpha = True # Use the standard formula for computing the step length in Conjugate Gradient
params.CG_forgetting_rate = None # Forgetting rate of the last conjugate direction
# Learning parameters for each feature type
deep_params.learning_rate = 0.0075 # Learning rate
deep_params.output_sigma_factor = 1 / 4 # Standard deviation of Gaussian label relative to target size
# Training parameters
params.sample_memory_size = 250 # Memory size
params.train_skipping = 5 # How often to run training (every n-th frame)
# Online model parameters
deep_params.kernel_size = (4, 4) # Kernel size of filter
deep_params.compressed_dim = 768 # Dimension output of projection matrix
deep_params.filter_reg = 1e-1 # Filter regularization factor
deep_params.projection_reg = 1e-4 # Projection regularization factor
# Windowing
params.feature_window = False # Perform windowing of features
params.window_output = True # Perform windowing of output scores
# Detection parameters
params.scale_factors = torch.Tensor([1.04 ** x for x in [-2, -1, 0, 1, 2]]) # Multi scale Test
params.score_upsample_factor = 1 # How much Fourier upsampling to use
# Init data augmentation parameters
params.augmentation = {'fliplr': True,
'rotate': [5, -5, 10, -10, 20, -20, 30, -30, 45, -45, -60, 60],
'blur': [(2, 0.2), (0.2, 2), (3, 1), (1, 3), (2, 2)],
'relativeshift': [(0.6, 0.6), (-0.6, 0.6), (0.6, -0.6), (-0.6, -0.6)],
'dropout': (7, 0.2)}
params.augmentation_expansion_factor = 2 # How much to expand sample when doing augmentation
params.random_shift_factor = 1 / 3 # How much random shift to do on each augmented sample
deep_params.use_augmentation = True # Whether to use augmentation for this feature
# Factorized convolution parameters
# params.use_projection_matrix = True # Use projection matrix, i.e. use the factorized convolution formulation
params.update_projection_matrix = True # Whether the projection matrix should be optimized or not
params.proj_init_method = 'randn' # Method for initializing the projection matrix
params.filter_init_method = 'randn' # Method for initializing the spatial filter
params.projection_activation = 'none' # Activation function after projection ('none', 'relu', 'elu' or 'mlu')
params.response_activation = (
'mlu', 0.05) # Activation function on the output scores ('none', 'relu', 'elu' or 'mlu')
# Advanced localization parameters
params.advanced_localization = True # Use this or not
params.target_not_found_threshold = -1 # Absolute score threshold to detect target missing
params.distractor_threshold = 100 # Relative threshold to find distractors
params.hard_negative_threshold = 0.3 # Relative threshold to find hard negative samples
params.target_neighborhood_scale = 2.2 # Target neighborhood to remove
params.dispalcement_scale = 0.7 # Dispacement to consider for distractors
params.hard_negative_learning_rate = 0.02 # Learning rate if hard negative detected
params.hard_negative_CG_iter = 5 # Number of optimization iterations to use if hard negative detected
params.update_scale_when_uncertain = True # Update scale or not if distractor is close
# IoUNet parameters
params.iounet_augmentation = False # Use the augmented samples to compute the modulation vector
params.iounet_k = 3 # Top-k average to estimate final box
params.num_init_random_boxes = 9 # Num extra random boxes in addition to the classifier prediction
params.box_jitter_pos = 0.1 # How much to jitter the translation for random boxes
params.box_jitter_sz = 0.5 # How much to jitter the scale for random boxes
params.maximal_aspect_ratio = 6 # Limit on the aspect ratio
params.box_refinement_iter = 10 # Number of iterations for refining the boxes
params.box_refinement_step_length = 1 # Gradient step length in the bounding box refinement
params.box_refinement_step_decay = 1 # Multiplicative step length decay (1 means no decay)
# Setup the feature extractor (which includes the IoUNet)
deep_fparams = FeatureParams(feature_params=[deep_params])
deep_feat = deep.ATOMResNet50(net_path='atom_vid_lasot_coco_resnet50_fpn_ATOMnet_ep0040.pth.tar',
output_layers=['layer3'], fparams=deep_fparams,
normalize_power=2)
params.features = MultiResolutionExtractor([deep_feat])
params.vot_anno_conversion_type = 'preserve_area'
return params
