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.exemplar_size = 127 params.instance_size = 287 params.base_size = 0 params.context_amount = 0.5 # Anchor parameters params.anchor_stride = 8 params.anchor_ratios = [0.33, 0.5, 1, 2, 3] params.anchor_scales = [8] # Tracking parameters params.penalty_k = 0.18 params.window_influence = 0.41 params.lr = 0.05 # Setup the feature extractor deep_fparams = FeatureParams(feature_params=[deep_params]) deep_feat = deep.SRPNAlexNet(fparams=deep_fparams) params.features = MultiResolutionExtractor([deep_feat]) 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.exemplar_size = 127 params.max_image_sample_size = 255 * 255 # Maximum image sample size params.min_image_sample_size = 255 * 255 # Minimum image sample size # Detection parameters params.scale_factors = 1.0375**np.array( [-1, 0, 1] ) # What scales to use for localization (only one scale if IoUNet is used) params.score_upsample_factor = 16 # How much Fourier upsampling to use params.scale_penalty = 0.9745 params.scale_lr = 0.59 params.window_influence = 0.176 params.total_stride = 8 # Setup the feature extractor (which includes the IoUNet) deep_fparams = FeatureParams(feature_params=[deep_params]) deep_feat = deep.SFCAlexnet( net_path= '/ssd2/bily/code/baidu/personal-code/pytracking/ltr/checkpoints/ltr/fs/siamrpn50/SiamRPN_ep0001.pth.tar', output_layers=['conv5'], fparams=deep_fparams) params.features = MultiResolutionExtractor([deep_feat]) params.net_path = None params.response_up = 16 params.response_sz = 17 params.context = 0.5 params.instance_sz = 255 params.exemplar_sz = 127 params.scale_num = 3 params.scale_step = 1.0375 params.scale_lr = 0.59 params.scale_penalty = 0.9745 params.window_influence = 0.176 params.total_stride = 8 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(gpu_device=0): params = TrackerParams() params.debug = 0 params.visualization = True params.visdom_info = {'use_visdom': False} params.use_gpu = True # Feature specific parameters shallow_params = TrackerParams() deep_params = TrackerParams() # Conjugate Gradient 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.post_init_CG_iter = 0 # CG iterations to run after GN params.fletcher_reeves = True # 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 = 75 # Forgetting rate of the last conjugate direction params.precond_data_param = 0.7 # Weight of the data term in the preconditioner params.precond_reg_param = 0.02 # Weight of the regularization term in the preconditioner # Learning parameters shallow_params.learning_rate = 0.025 deep_params.learning_rate = 0.0075 shallow_params.output_sigma_factor = 1 / 12 deep_params.output_sigma_factor = 1 / 4 # Training parameters params.sample_memory_size = 200 # Memory size # Detection parameters params.score_fusion_strategy = 'weightedsum' # Fusion strategy shallow_params.translation_weight = 0.4 # Weight of this feature deep_params.translation_weight = 1 - shallow_params.translation_weight # Init augmentation parameters params.augmentation = { 'fliplr': False, 'blur': [(2, 0.2), (0.2, 2), (3, 1), (1, 3), (2, 2)], 'dropout': (7, 0.2) } # Whether to use augmentation for this feature deep_params.use_augmentation = True shallow_params.use_augmentation = True # Interpolation parameters params.interpolation_method = 'bicubic' # The kind of interpolation kernel params.interpolation_bicubic_a = -0.75 # The parameter for the bicubic interpolation kernel params.interpolation_centering = False # Center the kernel at the feature sample params.interpolation_windowing = False # Do additional windowing on the Fourier coefficients of the kernel # Regularization parameters shallow_params.use_reg_window = True # Use spatial regularization or not shallow_params.reg_window_min = 1e-4 # The minimum value of the regularization window shallow_params.reg_window_edge = 10e-3 # The impact of the spatial regularization shallow_params.reg_window_power = 2 # The degree of the polynomial to use (e.g. 2 is a quadratic window) shallow_params.reg_sparsity_threshold = 0.1 # A relative threshold of which DFT coefficients that should be set to zero deep_params.use_reg_window = True # Use spatial regularization or not deep_params.reg_window_min = 10e-4 # The minimum value of the regularization window deep_params.reg_window_edge = 50e-3 # The impact of the spatial regularization deep_params.reg_window_power = 2 # The degree of the polynomial to use (e.g. 2 is a quadratic window) deep_params.reg_sparsity_threshold = 0.1 # A relative threshold of which DFT coefficients that should be set to zero fparams = FeatureParams(feature_params=[shallow_params, deep_params]) features = deep.ResNet18m1(output_layers=['vggconv1', 'layer3'], use_gpu=params.use_gpu, gpu_device=gpu_device, fparams=fparams, pool_stride=[2, 1], normalize_power=2) params.features = MultiResolutionExtractor([features]) 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 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 # Feature specific parameters shallow_params = TrackerParams() deep_params = TrackerParams() # Patch sampling parameters params.max_image_sample_size = 250**2 # Maximum image sample size params.min_image_sample_size = 200**2 # Minimum image sample size params.search_area_scale = 4.5 # Scale relative to target size # Conjugate Gradient 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 = 75 # Forgetting rate of the last conjugate direction params.precond_data_param = 0.3 # Weight of the data term in the preconditioner params.precond_reg_param = 0.15 # Weight of the regularization term in the preconditioner params.precond_proj_param = 35 # Weight of the projection matrix part in the preconditioner # Learning parameters shallow_params.learning_rate = 0.025 deep_params.learning_rate = 0.0075 shallow_params.output_sigma_factor = 1 / 16 deep_params.output_sigma_factor = 1 / 4 # Training parameters params.sample_memory_size = 200 # Memory size params.train_skipping = 10 # How often to run training (every n-th frame) # Detection parameters params.scale_factors = 1.02**torch.arange( -2, 3).float() # What scales to use for localization params.score_upsample_factor = 1 # How much Fourier upsampling to use params.score_fusion_strategy = 'weightedsum' # Fusion strategy shallow_params.translation_weight = 0.4 # Weight of this feature deep_params.translation_weight = 1 - shallow_params.translation_weight # Init 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)], 'shift': [(6, 6), (-6, 6), (6, -6), (-6, -6)], 'dropout': (7, 0.2) } # Whether to use augmentation for this feature deep_params.use_augmentation = True shallow_params.use_augmentation = True # 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 params.projection_reg = 5e-8 # Regularization paremeter of the projection matrix shallow_params.compressed_dim = 16 # Dimension output of projection matrix for shallow features deep_params.compressed_dim = 64 # Dimension output of projection matrix for deep features # Interpolation parameters params.interpolation_method = 'bicubic' # The kind of interpolation kernel params.interpolation_bicubic_a = -0.75 # The parameter for the bicubic interpolation kernel params.interpolation_centering = True # Center the kernel at the feature sample params.interpolation_windowing = False # Do additional windowing on the Fourier coefficients of the kernel # Regularization parameters shallow_params.use_reg_window = True # Use spatial regularization or not shallow_params.reg_window_min = 1e-4 # The minimum value of the regularization window shallow_params.reg_window_edge = 10e-3 # The impact of the spatial regularization shallow_params.reg_window_power = 2 # The degree of the polynomial to use (e.g. 2 is a quadratic window) shallow_params.reg_sparsity_threshold = 0.05 # A relative threshold of which DFT coefficients that should be set to zero deep_params.use_reg_window = True # Use spatial regularization or not deep_params.reg_window_min = 10e-4 # The minimum value of the regularization window deep_params.reg_window_edge = 50e-3 # The impact of the spatial regularization deep_params.reg_window_power = 2 # The degree of the polynomial to use (e.g. 2 is a quadratic window) deep_params.reg_sparsity_threshold = 0.1 # A relative threshold of which DFT coefficients that should be set to zero fparams = FeatureParams(feature_params=[shallow_params, deep_params]) features = deep.ResNet18m1(output_layers=['vggconv1', 'layer3'], use_gpu=params.use_gpu, fparams=fparams, pool_stride=[2, 1], normalize_power=2) params.features = MultiResolutionExtractor([features]) params.metric_model_path = '/home/zj/tracking/metricNet/0py_mdnet_metric_similar/pyMDNet/models/metric_model_zj_57470.pt' params.lof_rate = 1.8 params.sim_rate = 0.3 params.lt = False 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
def parameters(): params = TrackerParams() params.debug = 0 params.visualization = True params.visdom_info = {'use_visdom': False} params.use_gpu = True # Feature specific parameters shallow_params = TrackerParams() # Conjugate Gradient parameters params.CG_iter = 5 # The number of Conjugate Gradient iterations in each update after the first frame params.init_CG_iter = 50 # 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 = 75 # Forgetting rate of the last conjugate direction params.precond_data_param = 0.3 # Weight of the data term in the preconditioner params.precond_reg_param = 0.15 # Weight of the regularization term in the preconditioner params.precond_proj_param = 35 # Weight of the projection matrix part in the preconditioner # Learning parameters shallow_params.learning_rate = 0.025 shallow_params.output_sigma_factor = 1 / 4 #1/8 #1/16#1.0#1/16 # Training parameters params.sample_memory_size = 200 # Memory size params.train_skipping = 201 # How often to run training (every n-th frame) # Detection parameters params.score_upsample_factor = 1 # How much Fourier upsampling to use params.score_fusion_strategy = 'weightedsum' # Fusion strategy shallow_params.translation_weight = 1.0 # Weight of this feature # Init augmentation parameters params.augmentation = { 'fliplr': False, #'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)], #'shift': [(6, 6), (-6, 6), (6, -6), (-6,-6)], 'dropout': (7, 0.2) } # Whether to use augmentation for this feature #deep_params.use_augmentation = True shallow_params.use_augmentation = True # Interpolation parameters params.interpolation_method = 'bicubic' # The kind of interpolation kernel params.interpolation_bicubic_a = -0.75 # The parameter for the bicubic interpolation kernel params.interpolation_centering = True # Center the kernel at the feature sample params.interpolation_windowing = False # Do additional windowing on the Fourier coefficients of the kernel # Regularization parameters shallow_params.use_reg_window = True # Use spatial regularization or not shallow_params.reg_window_min = 1e-4 # The minimum value of the regularization window shallow_params.reg_window_edge = 10e-3 # The impact of the spatial regularization shallow_params.reg_window_power = 2 # The degree of the polynomial to use (e.g. 2 is a quadratic window) shallow_params.reg_sparsity_threshold = 0.05 # A relative threshold of which DFT coefficients that should be set to zero fparams = FeatureParams(feature_params=[shallow_params]) features = color.RGB(fparams=fparams, pool_stride=None, output_size=None, normalize_power=None, use_for_color=True, use_for_gray=False) params.features = MultiResolutionExtractor([features]) return params