repo stringlengths 1 99 | file stringlengths 13 215 | code stringlengths 12 59.2M | file_length int64 12 59.2M | avg_line_length float64 3.82 1.48M | max_line_length int64 12 2.51M | extension_type stringclasses 1
value |
|---|---|---|---|---|---|---|
Stark | Stark-main/external/AR/ltr/dataset/sbd.py | from .base_image_dataset import BaseImageDataset
from ltr.data.image_loader import jpeg4py_loader_w_failsafe
import torch
from collections import OrderedDict
import os
from scipy.io import loadmat
from ltr.data.bounding_box_utils import masks_to_bboxes
from ltr.admin.environment import env_settings
class SBD(BaseIma... | 3,978 | 33.301724 | 109 | py |
Stark | Stark-main/external/AR/ltr/dataset/got10k.py | import os
import os.path
import numpy as np
import torch
import csv
import pandas
import random
from collections import OrderedDict
from .base_video_dataset import BaseVideoDataset
from ltr.data.image_loader import jpeg4py_loader
from ltr.admin.environment import env_settings
class Got10k(BaseVideoDataset):
""" G... | 7,747 | 41.108696 | 130 | py |
Stark | Stark-main/external/AR/ltr/dataset/lvis.py | import os
from .base_image_dataset import BaseImageDataset
from ltr.data.image_loader import jpeg4py_loader_w_failsafe
import torch
import random
import lvis.lvis as lvis_pk
from collections import OrderedDict
from ltr.admin.environment import env_settings
class LVIS(BaseImageDataset):
""" The LVIS object detecti... | 5,546 | 35.254902 | 124 | py |
Stark | Stark-main/external/AR/ltr/dataset/coco.py | import os
from .base_image_dataset import BaseImageDataset
from ltr.data.image_loader import jpeg4py_loader
import torch
from pycocotools.coco import COCO
import random
from collections import OrderedDict
from ltr.admin.environment import env_settings
class MSCOCO(BaseImageDataset):
""" The COCO object detection ... | 5,765 | 35.726115 | 120 | py |
Stark | Stark-main/external/AR/ltr/dataset/coco_seq.py | import os
from .base_video_dataset import BaseVideoDataset
from ltr.data.image_loader import jpeg4py_loader
import torch
import random
from pycocotools.coco import COCO
from collections import OrderedDict
from ltr.admin.environment import env_settings
class MSCOCOSeq(BaseVideoDataset):
""" The COCO dataset. COCO ... | 6,298 | 36.272189 | 120 | py |
Stark | Stark-main/external/AR/ltr/dataset/msra10k.py | import os
from .base_image_dataset import BaseImageDataset
from ltr.data.image_loader import jpeg4py_loader, imread_indexed
import torch
from collections import OrderedDict
from ltr.admin.environment import env_settings
from ltr.data.bounding_box_utils import masks_to_bboxes
class MSRA10k(BaseImageDataset):
"""
... | 3,123 | 34.5 | 120 | py |
Stark | Stark-main/external/AR/ltr/dataset/base_video_dataset.py | import torch.utils.data
from ltr.data.image_loader import jpeg4py_loader
class BaseVideoDataset(torch.utils.data.Dataset):
""" Base class for video datasets """
def __init__(self, name, root, image_loader=jpeg4py_loader):
"""
args:
root - The root path to the dataset
i... | 3,024 | 26.5 | 121 | py |
Stark | Stark-main/external/AR/ltr/models/backbone/base.py | import torch
import torch.nn as nn
class Backbone(nn.Module):
"""Base class for backbone networks. Handles freezing layers etc.
args:
frozen_layers - Name of layers to freeze. Either list of strings, 'none' or 'all'. Default: 'none'.
"""
def __init__(self, frozen_layers=()):
super().... | 1,611 | 33.297872 | 151 | py |
Stark | Stark-main/external/AR/ltr/models/backbone/resnet.py | import math
import torch.nn as nn
from collections import OrderedDict
import torch.utils.model_zoo as model_zoo
from torchvision.models.resnet import model_urls
from .base import Backbone
def conv3x3(in_planes, out_planes, stride=1, dilation=1):
"""3x3 convolution with padding"""
return nn.Conv2d(in_planes, o... | 9,442 | 33.463504 | 123 | py |
Stark | Stark-main/external/AR/ltr/models/backbone/resnet_seg.py | import math
import torch.nn as nn
from collections import OrderedDict
import torch.utils.model_zoo as model_zoo
from torchvision.models.resnet import model_urls
'''2020.4.14 newly added'''
from collections import OrderedDict as odict
from ltr.models.head.utils import get_out_channels
def conv3x3(in_planes, out_planes,... | 8,770 | 34.8 | 123 | py |
Stark | Stark-main/external/AR/ltr/models/backbone/resnet18_vggm.py | import math
import torch
import torch.nn as nn
from collections import OrderedDict
from torchvision.models.resnet import BasicBlock
from .base import Backbone
class SpatialCrossMapLRN(nn.Module):
def __init__(self, local_size=1, alpha=1.0, beta=0.75, k=1, ACROSS_CHANNELS=True):
super(SpatialCrossMapLRN, s... | 5,522 | 33.735849 | 92 | py |
Stark | Stark-main/external/AR/ltr/models/meta/steepestdescent.py | import math
import torch
import torch.nn as nn
from pytracking import TensorList
from ltr.models.layers import activation
class GNSteepestDescent(nn.Module):
"""General module for steepest descent based meta learning."""
def __init__(self, residual_module, num_iter=1, compute_losses=False, detach_length=float... | 3,524 | 36.903226 | 124 | py |
Stark | Stark-main/external/AR/ltr/models/AR_seg_mask/AR_seg_mask.py | import torch.nn as nn
from ltr.models.neck import CorrNL
from ltr import model_constructor
import torch
import ltr.models.backbone.resnet_seg as resnet_seg
from ltr.models.head import seg_network
from easydict import EasyDict as edict
'''2020.4.14 replace mask head with frtm for higher-quality mask'''
'''2020.4.22 On... | 5,452 | 44.441667 | 158 | py |
Stark | Stark-main/external/AR/ltr/models/bbreg/atom_iou_net.py | import torch.nn as nn
import torch
from ltr.models.layers.blocks import LinearBlock
from ltr.external.PreciseRoIPooling.pytorch.prroi_pool import PrRoIPool2D
def conv(in_planes, out_planes, kernel_size=3, stride=1, padding=1, dilation=1):
return nn.Sequential(
nn.Conv2d(in_planes, out_planes, kernel_s... | 7,601 | 41.233333 | 137 | py |
Stark | Stark-main/external/AR/ltr/models/bbreg/atom.py | import torch.nn as nn
import ltr.models.backbone as backbones
import ltr.models.bbreg as bbmodels
from ltr import model_constructor
class ATOMnet(nn.Module):
""" ATOM network module"""
def __init__(self, feature_extractor, bb_regressor, bb_regressor_layer, extractor_grad=True):
"""
args:
... | 3,542 | 40.197674 | 124 | py |
Stark | Stark-main/external/AR/ltr/models/neck/CorrNL.py | import torch.nn as nn
import torch
from ltr.external.PreciseRoIPooling.pytorch.prroi_pool import PrRoIPool2D
from torch.nn import functional as F
from ltr.models.neck.neck_utils import *
class CorrNL(nn.Module):
"""Network module for IoU prediction. Refer to the ATOM paper for an illustration of the architecture.
... | 5,179 | 43.655172 | 117 | py |
Stark | Stark-main/external/AR/ltr/models/neck/neck_utils.py | import torch.nn as nn
import torch
from torch.nn import functional as F
def conv(in_planes, out_planes, kernel_size=3, stride=1, padding=1, dilation=1):
return nn.Sequential(
nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride,
padding=padding, dilation=dilatio... | 4,841 | 35.134328 | 102 | py |
Stark | Stark-main/external/AR/ltr/models/head/seg_network.py | import torch
from torch import nn as nn
from torch.nn import functional as F
from ltr.models.head.utils import conv, relu, interpolate, adaptive_cat
class TSE(nn.Module):
def __init__(self, fc, ic, oc):
super().__init__()
nc = ic + oc
self.reduce = nn.Sequential(conv(fc, oc, 1), relu(), ... | 6,775 | 31.7343 | 113 | py |
Stark | Stark-main/external/AR/ltr/models/head/utils.py | from collections import OrderedDict as odict
import numpy as np
import torch
from torch import nn as nn
from torch.nn import functional as F
def text_bargraph(values):
blocks = np.array(('u', ' ', '▁', '▂', '▃', '▄', '▅', '▆', '▇', '█', 'o'))
nsteps = len(blocks) - 2 - 1
hstep = 1 / (2 * nsteps)
valu... | 3,388 | 26.778689 | 130 | py |
Stark | Stark-main/external/AR/ltr/models/layers/activation.py | import math
import torch
import torch.nn as nn
import torch.nn.functional as F
def softmax_reg(x: torch.Tensor, dim, reg=None):
"""Softmax with optinal denominator regularization."""
if reg is None:
return torch.softmax(x, dim=dim)
dim %= x.dim()
if isinstance(reg, (float, int)):
reg =... | 1,860 | 26.367647 | 115 | py |
Stark | Stark-main/external/AR/ltr/models/layers/filter.py | import torch
import torch.nn.functional as F
def apply_filter(feat, filter, dilation_factors=None):
"""Applies the filter on the input features (feat). The number of groups is automatically calculated.
args:
feat: These are the input features. Must have dimensions (images_in_sequence, sequences, feat_... | 8,433 | 44.836957 | 163 | py |
Stark | Stark-main/external/AR/ltr/models/layers/transform.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from collections import OrderedDict
def interpolate(x, sz):
"""Interpolate 4D tensor x to size sz."""
sz = sz.tolist() if torch.is_tensor(sz) else sz
return F.interpolate(x, sz, mode='bilinear', align_corners=False) if x.shape[-2:] != sz e... | 800 | 29.807692 | 98 | py |
Stark | Stark-main/external/AR/ltr/models/layers/normalization.py | import torch
import torch.nn as nn
import torch.nn.functional as F
class InstanceL2Norm(nn.Module):
"""Instance L2 normalization.
"""
def __init__(self, size_average=True, eps=1e-5, scale=1.0):
super().__init__()
self.size_average = size_average
self.eps = eps
self.scale = ... | 764 | 33.772727 | 140 | py |
Stark | Stark-main/external/AR/ltr/models/layers/distance.py | import torch
import torch.nn as nn
import torch.nn.functional as F
class DistanceMap(nn.Module):
"""Generate a distance map from a origin center location.
args:
num_bins: Number of bins in the map.
bin_displacement: Displacement of the bins.
"""
def __init__(self, num_bins, bin_displ... | 1,423 | 32.904762 | 110 | py |
Stark | Stark-main/external/AR/ltr/models/layers/blocks.py | from torch import nn
def conv_block(in_planes, out_planes, kernel_size=3, stride=1, padding=1, dilation=1, bias=True,
batch_norm=True, relu=True, padding_mode='zeros'):
layers = []
assert padding_mode == 'zeros' or padding_mode == 'replicate'
if padding_mode == 'replicate' and padding > 0:... | 1,397 | 37.833333 | 96 | py |
Stark | Stark-main/external/AR/ltr/models/loss/kl_regression.py | import math
import torch
import torch.nn as nn
from torch.nn import functional as F
class KLRegression(nn.Module):
"""KL-divergence loss for probabilistic regression.
It is computed using Monte Carlo (MC) samples from an arbitrary distribution."""
def __init__(self, eps=0.0):
super().__init__()
... | 2,530 | 34.647887 | 105 | py |
Stark | Stark-main/external/AR/ltr/models/loss/target_classification.py | import torch.nn as nn
import torch
from torch.nn import functional as F
class LBHinge(nn.Module):
"""Loss that uses a 'hinge' on the lower bound.
This means that for samples with a label value smaller than the threshold, the loss is zero if the prediction is
also smaller than that threshold.
args:
... | 1,191 | 36.25 | 116 | py |
Stark | Stark-main/external/AR/ltr/models/tracking/dimpnet.py | import math
import torch
import torch.nn as nn
from collections import OrderedDict
from ltr.models.meta import steepestdescent
import ltr.models.target_classifier.linear_filter as target_clf
import ltr.models.target_classifier.features as clf_features
import ltr.models.target_classifier.initializer as clf_initializer
i... | 19,303 | 55.279883 | 125 | py |
Stark | Stark-main/external/AR/ltr/models/target_classifier/features.py | import torch
from torch import nn
import torch.nn.functional as F
from torchvision.models.resnet import BasicBlock, Bottleneck
from ltr.models.layers.normalization import InstanceL2Norm
from ltr.models.layers.transform import InterpCat
def residual_basic_block(feature_dim=256, num_blocks=1, l2norm=True, final_conv=Fa... | 3,046 | 43.15942 | 121 | py |
Stark | Stark-main/external/AR/ltr/models/target_classifier/residual_modules.py | import torch
import torch.nn as nn
import math
import ltr.models.layers.filter as filter_layer
import ltr.models.layers.activation as activation
from ltr.models.layers.distance import DistanceMap
from pytracking import TensorList
class LinearFilterLearnGen(nn.Module):
def __init__(self, feat_stride=16, init_filte... | 3,840 | 43.662791 | 139 | py |
Stark | Stark-main/external/AR/ltr/models/target_classifier/linear_filter.py | import torch.nn as nn
import ltr.models.layers.filter as filter_layer
import math
class LinearFilter(nn.Module):
"""Target classification filter module.
args:
filter_size: Size of filter (int).
filter_initialize: Filter initializer module.
filter_optimizer: Filter optimizer module.
... | 5,405 | 40.267176 | 118 | py |
Stark | Stark-main/external/AR/ltr/models/target_classifier/initializer.py | import torch.nn as nn
import torch
import torch.nn.functional as F
from ltr.external.PreciseRoIPooling.pytorch.prroi_pool import PrRoIPool2D
from ltr.models.layers.blocks import conv_block
import math
class FilterPool(nn.Module):
"""Pool the target region in a feature map.
args:
filter_size: Size of ... | 10,465 | 41.032129 | 129 | py |
Stark | Stark-main/external/AR/ltr/models/target_classifier/optimizer.py | import torch.nn as nn
import torch
import torch.nn.functional as F
import ltr.models.layers.filter as filter_layer
import ltr.models.layers.activation as activation
from ltr.models.layers.distance import DistanceMap
import math
class DiMPSteepestDescentGN(nn.Module):
"""Optimizer module for DiMP.
It unrolls ... | 23,277 | 51.904545 | 163 | py |
Stark | Stark-main/external/AR/ltr/actors/tracking.py | from . import BaseActor
import torch
class DiMPActor(BaseActor):
"""Actor for training the DiMP network."""
def __init__(self, net, objective, loss_weight=None):
super().__init__(net, objective)
if loss_weight is None:
loss_weight = {'iou': 1.0, 'test_clf': 1.0}
self.loss_w... | 9,035 | 45.57732 | 126 | py |
Stark | Stark-main/external/AR/ltr/admin/loading.py | import torch
import os
import sys
from pathlib import Path
import importlib
import inspect
from ltr.admin import settings as ws_settings
def load_trained_network(workspace_dir, network_path, checkpoint=None):
"""OUTDATED. Use load_pretrained instead!"""
checkpoint_dir = os.path.join(workspace_dir, 'checkpoint... | 5,567 | 35.874172 | 119 | py |
Stark | Stark-main/external/AR/ltr/admin/tensorboard.py | import os
from collections import OrderedDict
try:
from torch.utils.tensorboard import SummaryWriter
except:
print('WARNING: You are using tensorboardX instead sis you have a too old pytorch version.')
from tensorboardX import SummaryWriter
class TensorboardWriter:
def __init__(self, directory, loader... | 1,251 | 43.714286 | 117 | py |
Stark | Stark-main/external/AR/ltr/admin/multigpu.py | import torch.nn as nn
def is_multi_gpu(net):
return isinstance(net, (MultiGPU, nn.DataParallel))
class MultiGPU(nn.DataParallel):
"""Wraps a network to allow simple multi-GPU training."""
def __getattr__(self, item):
try:
return super().__getattr__(item)
except:
p... | 365 | 23.4 | 61 | py |
Stark | Stark-main/external/AR/ltr/data/processing_utils.py | import torch
import math
import cv2 as cv
import random
import torch.nn.functional as F
from .bounding_box_utils import rect_to_rel, rel_to_rect
def sample_target(im, target_bb, search_area_factor, output_sz=None, mask=None):
""" Extracts a square crop centered at target_bb box, of area search_area_factor^2 times... | 23,093 | 35.832536 | 130 | py |
Stark | Stark-main/external/AR/ltr/data/sampler.py | import random
import torch.utils.data
from pytracking import TensorDict
def no_processing(data):
return data
class TrackingSampler(torch.utils.data.Dataset):
""" Class responsible for sampling frames from training sequences to form batches. Each training sample is a
tuple consisting of i) a set of train... | 9,665 | 50.142857 | 123 | py |
Stark | Stark-main/external/AR/ltr/data/processing_utils_SE.py | import torch
import math
import cv2 as cv
import random
import numpy as np
def stack_tensors(x):
if isinstance(x, list) and isinstance(x[0], torch.Tensor):
return torch.stack(x)
return x
'''Added on 2019.12.23'''
def sample_target_SE(im, target_bb, search_area_factor, output_sz=None, mode=cv.BORDER_... | 16,646 | 35.911308 | 145 | py |
Stark | Stark-main/external/AR/ltr/data/processing.py | import torch
import torchvision.transforms as transforms
from pytracking import TensorDict
import ltr.data.processing_utils as prutils
def stack_tensors(x):
if isinstance(x, (list, tuple)) and isinstance(x[0], torch.Tensor):
return torch.stack(x)
return x
class BaseProcessing:
""" Base class for... | 35,017 | 51.817496 | 143 | py |
Stark | Stark-main/external/AR/ltr/data/bounding_box_utils.py | import torch
def rect_to_rel(bb, sz_norm=None):
"""Convert standard rectangular parametrization of the bounding box [x, y, w, h]
to relative parametrization [cx/sw, cy/sh, log(w), log(h)], where [cx, cy] is the center coordinate.
args:
bb - N x 4 tensor of boxes.
sz_norm - [N] x 2 tens... | 2,979 | 30.368421 | 104 | py |
Stark | Stark-main/external/AR/ltr/data/loader.py | import torch
import torch.utils.data.dataloader
import importlib
import collections
from torch._six import string_classes, int_classes
from pytracking import TensorDict, TensorList
def _check_use_shared_memory():
if hasattr(torch.utils.data.dataloader, '_use_shared_memory'):
return getattr(torch.utils.dat... | 9,377 | 48.357895 | 116 | py |
Stark | Stark-main/external/AR/ltr/data/transforms.py | import random
import numpy as np
import math
import cv2 as cv
import torch
import torch.nn.functional as F
import torchvision.transforms.functional as tvisf
class Transform:
"""A set of transformations, used for e.g. data augmentation.
Args of constructor:
transforms: An arbitrary number of transforma... | 16,893 | 37.30839 | 162 | py |
Stark | Stark-main/external/AR/ltr/trainers/base_trainer.py | import os
import glob
import torch
import traceback
from ltr.admin import loading, multigpu
class BaseTrainer:
"""Base trainer class. Contains functions for training and saving/loading chackpoints.
Trainer classes should inherit from this one and overload the train_epoch function."""
def __init__(self, a... | 7,957 | 37.444444 | 118 | py |
Stark | Stark-main/external/AR/ltr/trainers/ltr_trainer.py | import os
from collections import OrderedDict
from ltr.trainers import BaseTrainer
from ltr.admin.stats import AverageMeter, StatValue
from ltr.admin.tensorboard import TensorboardWriter
import torch
import time
class LTRTrainer(BaseTrainer):
def __init__(self, actor, loaders, optimizer, settings, lr_scheduler=No... | 5,434 | 38.963235 | 127 | py |
Stark | Stark-main/external/AR/pytracking/ARcm_seg.py | import os
import sys
import torch
import numpy as np
import cv2
import torch.nn as nn
from external.AR.pytracking.utils.loading import load_network
from external.AR.ltr.data.processing_utils_SE import sample_target_SE, transform_image_to_crop_SE, map_mask_back
env_path = os.path.join(os.path.dirname(__file__), '..')
if... | 4,059 | 36.943925 | 119 | py |
Stark | Stark-main/external/AR/pytracking/tracker/atom/optim.py | import torch
from pytracking import optimization, TensorList, operation
import math
class FactorizedConvProblem(optimization.L2Problem):
def __init__(self, training_samples: TensorList, y:TensorList, filter_reg: torch.Tensor, projection_reg, params, sample_weights: TensorList,
projection_activati... | 3,622 | 35.23 | 144 | py |
Stark | Stark-main/external/AR/pytracking/tracker/atom/atom.py | from pytracking.tracker.base import BaseTracker
import torch
import torch.nn.functional as F
import torch.nn
import math
import time
from pytracking import dcf, fourier, TensorList, operation
from pytracking.features.preprocessing import numpy_to_torch
from pytracking.utils.plotting import show_tensor
from pytracking.l... | 40,346 | 47.204301 | 221 | py |
Stark | Stark-main/external/AR/pytracking/tracker/dimp/dimp.py | from pytracking.tracker.base import BaseTracker
import torch
import torch.nn.functional as F
import math
import time
from pytracking import dcf, TensorList
from pytracking.features.preprocessing import numpy_to_torch
from pytracking.utils.plotting import show_tensor, plot_graph
from pytracking.features.preprocessing im... | 41,079 | 46.43649 | 207 | py |
Stark | Stark-main/external/AR/pytracking/tracker/eco/optim.py | import torch
import torch.nn.functional as F
from pytracking import complex, optimization, fourier, TensorList
from pytracking.utils.plotting import plot_graph
import math
class FactorizedConvProblem(optimization.L2Problem):
def __init__(self, training_samples: TensorList, yf:TensorList, reg_filter: torch.Tensor,... | 8,301 | 38.722488 | 166 | py |
Stark | Stark-main/external/AR/pytracking/tracker/eco/eco.py | from pytracking.tracker.base import BaseTracker
import torch
import torch.nn.functional as F
import math
from pytracking import complex, dcf, fourier, TensorList
from pytracking.libs.tensorlist import tensor_operation
from pytracking.features.preprocessing import numpy_to_torch
from pytracking.utils.plotting import sho... | 17,476 | 44.394805 | 167 | py |
Stark | Stark-main/external/AR/pytracking/evaluation/tracker.py | import importlib
import os
import numpy as np
from collections import OrderedDict
from pytracking.evaluation.environment import env_settings
import time
import cv2 as cv
from pytracking.utils.visdom import Visdom
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from pytracking.utils.plotting import ... | 26,003 | 36.469741 | 136 | py |
Stark | Stark-main/external/AR/pytracking/features/deep.py | from pytracking.features.featurebase import FeatureBase, MultiFeatureBase
import torch
import torchvision
from pytracking import TensorList
from pytracking.evaluation.environment import env_settings
import os
from pytracking.utils.loading import load_network
from ltr.models.backbone.resnet18_vggm import resnet18_vggmco... | 5,566 | 35.86755 | 120 | py |
Stark | Stark-main/external/AR/pytracking/features/preprocessing.py | import torch
import torch.nn.functional as F
import numpy as np
def numpy_to_torch(a: np.ndarray):
return torch.from_numpy(a).float().permute(2, 0, 1).unsqueeze(0)
def torch_to_numpy(a: torch.Tensor):
return a.squeeze(0).permute(1,2,0).numpy()
def sample_patch_transformed(im, pos, scale, image_sz, transfo... | 5,108 | 33.993151 | 129 | py |
Stark | Stark-main/external/AR/pytracking/features/augmentation.py | import numpy as np
import math
import torch
import torch.nn.functional as F
import cv2 as cv
import random
from pytracking.features.preprocessing import numpy_to_torch, torch_to_numpy
class Transform:
"""Base data augmentation transform class."""
def __init__(self, output_sz = None, shift = None):
se... | 8,872 | 37.081545 | 125 | py |
Stark | Stark-main/external/AR/pytracking/features/featurebase.py | import torch
import torch.nn.functional as F
from pytracking import TensorList
class FeatureBase:
"""Base feature class.
args:
fparams: Feature specific parameters.
pool_stride: Amount of average pooling to apply do downsample the feature map.
output_size: Alternatively, specify the ou... | 4,218 | 37.354545 | 146 | py |
Stark | Stark-main/external/AR/pytracking/features/color.py | import torch
from pytracking.features.featurebase import FeatureBase
class RGB(FeatureBase):
"""RGB feature normalized to [-0.5, 0.5]."""
def dim(self):
return 3
def stride(self):
return self.pool_stride
def extract(self, im: torch.Tensor):
return im/255 - 0.5
class Graysca... | 582 | 20.592593 | 56 | py |
Stark | Stark-main/external/AR/pytracking/features/extractor.py | import torch
from pytracking.features.preprocessing import sample_patch
from pytracking import TensorList
class ExtractorBase:
"""Base feature extractor class.
args:
features: List of features.
"""
def __init__(self, features):
self.features = features
def initialize(self):
... | 5,230 | 35.326389 | 120 | py |
Stark | Stark-main/external/AR/pytracking/features/net_wrappers.py | import torch
from pytracking.utils.loading import load_network
class NetWrapper:
"""Used for wrapping networks in pytracking.
Network modules and functions can be accessed directly as if they were members of this class."""
_rec_iter=0
def __init__(self, net_path, use_gpu=True, initialize=False, **kwar... | 2,437 | 31.078947 | 100 | py |
Stark | Stark-main/external/AR/pytracking/features/util.py | import torch
from pytracking.features.featurebase import FeatureBase
class Concatenate(FeatureBase):
"""A feature that concatenates other features.
args:
features: List of features to concatenate.
"""
def __init__(self, features, pool_stride = None, normalize_power = None, use_for_color = True... | 990 | 35.703704 | 120 | py |
Stark | Stark-main/external/AR/pytracking/parameter/atom/atom_prob_ml.py | from pytracking.utils import TrackerParams, FeatureParams, Choice
from pytracking.features.extractor import MultiResolutionExtractor
from pytracking.features import deep
import torch
def parameters():
params = TrackerParams()
# These are usually set from outside
params.debug = 0 # D... | 6,540 | 60.707547 | 146 | py |
Stark | Stark-main/external/AR/pytracking/parameter/atom/multiscale_no_iounet.py | from pytracking.utils import TrackerParams, FeatureParams, Choice
from pytracking.features.extractor import MultiResolutionExtractor
from pytracking.features import deep
import torch
def parameters():
params = TrackerParams()
# These are usually set from outside
params.debug = 0 # D... | 6,503 | 60.942857 | 146 | py |
Stark | Stark-main/external/AR/pytracking/parameter/atom/default.py | from pytracking.utils import TrackerParams, FeatureParams, Choice
from pytracking.features.extractor import MultiResolutionExtractor
from pytracking.features import deep
import torch
def parameters():
params = TrackerParams()
# These are usually set from outside
params.debug = 0 # D... | 6,482 | 60.742857 | 146 | py |
Stark | Stark-main/external/AR/pytracking/parameter/atom/atom_gmm_sampl.py | from pytracking.utils import TrackerParams, FeatureParams, Choice
from pytracking.features.extractor import MultiResolutionExtractor
from pytracking.features import deep
import torch
def parameters():
params = TrackerParams()
# These are usually set from outside
params.debug = 0 # D... | 6,551 | 60.811321 | 146 | py |
Stark | Stark-main/external/AR/pytracking/parameter/atom/default_vot.py | from pytracking.utils import TrackerParams, FeatureParams, Choice
from pytracking.features.extractor import MultiResolutionExtractor
from pytracking.features import deep
import torch
def parameters():
params = TrackerParams()
# These are usually set from outside
params.debug = 0 # D... | 6,516 | 61.663462 | 148 | py |
Stark | Stark-main/external/AR/pytracking/parameter/eco/default.py | from pytracking.utils import TrackerParams, FeatureParams
from pytracking.features.extractor import MultiResolutionExtractor
from pytracking.features import deep
import torch
def parameters():
params = TrackerParams()
params.debug = 0
params.visualization = False
params.use_gpu = True
# Feature ... | 5,595 | 56.690722 | 146 | py |
Stark | Stark-main/external/AR/pytracking/analysis/plot_results.py | import tikzplotlib
import matplotlib
import matplotlib.pyplot as plt
import os
import torch
import pickle
import json
from pytracking.evaluation.environment import env_settings
from pytracking.analysis.extract_results import extract_results
def get_plot_draw_styles():
plot_draw_style = [{'color': (1.0, 0.0, 0.0),... | 22,649 | 45.797521 | 131 | py |
Stark | Stark-main/external/AR/pytracking/analysis/evaluate_vos.py | import os
import numpy as np
import torch
import pandas as pd
from collections import OrderedDict
from ltr.data.image_loader import imread_indexed
from pytracking.evaluation import get_dataset
from pathlib import Path
from pytracking.analysis.plot_results import generate_formatted_report
import pytracking.analysis.vos... | 7,681 | 37.41 | 135 | py |
Stark | Stark-main/external/AR/pytracking/analysis/playback_results.py | import os
import sys
import importlib
import numpy as np
import torch
import time
import matplotlib.patches as patches
import cv2 as cv
import matplotlib.pyplot as plt
from pytracking.analysis.plot_results import get_plot_draw_styles
from pytracking.utils.plotting import draw_figure
from pytracking.evaluation import ge... | 6,518 | 35.830508 | 118 | py |
Stark | Stark-main/external/AR/pytracking/analysis/extract_results.py | import os
import sys
import importlib
import numpy as np
from pytracking.utils.load_text import load_text
import torch
import pickle
from tqdm import tqdm
env_path = os.path.join(os.path.dirname(__file__), '../..')
if env_path not in sys.path:
sys.path.append(env_path)
from pytracking.evaluation.environment impor... | 7,751 | 41.130435 | 171 | py |
Stark | Stark-main/external/AR/pytracking/analysis/vos_utils.py | import warnings
import numpy as np
from skimage.morphology import binary_dilation, disk
from math import floor
def text_bargraph(values):
blocks = np.array(('u', ' ', '▁', '▂', '▃', '▄', '▅', '▆', '▇', '█', 'o'))
nsteps = len(blocks)-2-1
hstep = 1 / (2*nsteps)
values = np.array(values)
nans = np.... | 6,689 | 27.347458 | 79 | py |
Stark | Stark-main/external/AR/pytracking/VOT2020_super_only_mask_384_HP/dimp_alpha_seg_class.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import cv2
import torch
import vot
import sys
import time
'''Refine module & Pytracking base trackers'''
import os
from pytracking.evaluation import Tracker
from pytrack... | 6,724 | 42.387097 | 99 | py |
Stark | Stark-main/external/AR/pytracking/VOT2020_super_only_mask_384_HP/stark_alpha_seg_class.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import cv2
import torch
import vot
import sys
import time
import os
from lib.test.evaluation import Tracker
from pytracking.ARcm_seg import ARcm_seg
from pytracking.vot20... | 5,943 | 43.358209 | 100 | py |
Stark | Stark-main/external/AR/pytracking/utils/visdom.py | import visdom
import visdom.server
from pytracking.features.preprocessing import numpy_to_torch
from pytracking.utils.plotting import show_image_with_boxes, overlay_mask
import cv2
import torch
import copy
import numpy as np
from collections import OrderedDict
class VisBase:
def __init__(self, visdom, show_data, ... | 16,200 | 36.764569 | 141 | py |
Stark | Stark-main/external/AR/pytracking/utils/plotting.py | import matplotlib.pyplot as plt
import numpy as np
import torch
import cv2
def draw_figure(fig):
fig.canvas.draw()
fig.canvas.flush_events()
plt.pause(0.001)
def show_tensor(a: torch.Tensor, fig_num = None, title = None, range=(None, None), ax=None):
"""Display a 2D tensor.
args:
fig_num... | 5,226 | 32.50641 | 115 | py |
Stark | Stark-main/external/AR/pytracking/libs/optimization.py | import torch
import torch.autograd
import math
from pytracking.libs import TensorList
from pytracking.utils.plotting import plot_graph
from ltr.models.layers.activation import softmax_reg
class L2Problem:
"""Base class for representing an L2 optimization problem."""
def __call__(self, x: TensorList) -> Tenso... | 21,949 | 29.742297 | 154 | py |
Stark | Stark-main/external/AR/pytracking/libs/tensorlist.py | import functools
import torch
import copy
class TensorList(list):
"""Container mainly used for lists of torch tensors. Extends lists with pytorch functionality."""
def __init__(self, list_of_tensors = None):
if list_of_tensors is None:
list_of_tensors = list()
super(TensorList, se... | 7,058 | 32.140845 | 101 | py |
Stark | Stark-main/external/AR/pytracking/libs/complex.py | import torch
from pytracking.libs.tensorlist import tensor_operation
def is_complex(a: torch.Tensor) -> bool:
return a.dim() >= 4 and a.shape[-1] == 2
def is_real(a: torch.Tensor) -> bool:
return not is_complex(a)
@tensor_operation
def mult(a: torch.Tensor, b: torch.Tensor):
"""Pointwise complex multi... | 5,981 | 27.216981 | 96 | py |
Stark | Stark-main/external/AR/pytracking/libs/fourier.py | import torch
import torch.nn.functional as F
from pytracking import complex, TensorList
from pytracking.libs.tensorlist import tensor_operation
@tensor_operation
def rfftshift2(a: torch.Tensor):
h = a.shape[2] + 2
return torch.cat((a[:,:,(h-1)//2:,...], a[:,:,:h//2,...]), 2)
@tensor_operation
def irfftshift... | 4,537 | 30.082192 | 136 | py |
Stark | Stark-main/external/AR/pytracking/libs/tensordict.py | from collections import OrderedDict
import torch
import copy
class TensorDict(OrderedDict):
"""Container mainly used for dicts of torch tensors. Extends OrderedDict with pytorch functionality."""
def concat(self, other):
"""Concatenates two dicts without copying internal data."""
return Tenso... | 1,228 | 32.216216 | 121 | py |
Stark | Stark-main/external/AR/pytracking/libs/operation.py | import torch
import torch.nn.functional as F
from pytracking.libs.tensorlist import tensor_operation, TensorList
@tensor_operation
def conv2d(input: torch.Tensor, weight: torch.Tensor, bias: torch.Tensor = None, stride=1, padding=0, dilation=1, groups=1, mode=None):
"""Standard conv2d. Returns the input if weight... | 1,509 | 34.116279 | 135 | py |
Stark | Stark-main/external/AR/pytracking/libs/dcf.py | import torch
import math
from pytracking import fourier
from pytracking import complex
import torch.nn.functional as F
def hann1d(sz: int, centered = True) -> torch.Tensor:
"""1D cosine window."""
if centered:
return 0.5 * (1 - torch.cos((2 * math.pi / (sz + 1)) * torch.arange(1, sz + 1).float()))
... | 6,931 | 41.012121 | 150 | py |
Stark | Stark-main/lib/models/stark/backbone_X.py | """
Backbone modules.
"""
import torch
import torch.nn.functional as F
from torch import nn
from lib.utils.misc import is_main_process
from lib.models.stark import resnet as resnet_module
from lib.models.stark.repvgg import get_RepVGG_func_by_name
import os
from .swin_transformer import build_swint
class FrozenBatch... | 8,238 | 42.592593 | 115 | py |
Stark | Stark-main/lib/models/stark/swin_transformer.py | # --------------------------------------------------------
# Swin Transformer
# Copyright (c) 2021 Microsoft
# Licensed under The MIT License [see LICENSE for details]
# Written by Ze Liu, Yutong Lin, Yixuan Wei
# --------------------------------------------------------
import torch
import torch.nn as nn
import torch.... | 26,081 | 38.398792 | 119 | py |
Stark | Stark-main/lib/models/stark/resnet.py | import torch
import torch.nn as nn
from torchvision.models.utils import load_state_dict_from_url
from torchvision.models.resnet import BasicBlock, Bottleneck, conv1x1, conv3x3
'''2021.1.5 Modified from torchvision.models.resnet
Now the
'''
__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
... | 12,004 | 42.33935 | 107 | py |
Stark | Stark-main/lib/models/stark/stark_lightning_x_trt.py | """
2021.06.24 STARK Lightning-X Model (Spatial-only).
2021.06.27 for converting pytorch model to trt model
"""
import torch
from torch import nn
import torch.nn.functional as F
from .backbone_X import build_backbone_x
from .position_encoding import build_position_encoding_new
from .lite_encoder import build_lite_encod... | 8,332 | 42.401042 | 119 | py |
Stark | Stark-main/lib/models/stark/repvgg.py | import torch.nn as nn
import numpy as np
import torch
import copy
class FrozenBatchNorm2d(torch.nn.Module):
"""
BatchNorm2d where the batch statistics and the affine parameters are fixed.
Copy-paste from torchvision.misc.ops with added eps before rqsrt,
without which any other models than torchvision... | 13,972 | 45.421927 | 141 | py |
Stark | Stark-main/lib/models/stark/transformer_enc.py | """
Transformer encoder class
"""
import copy
import torch.nn.functional as F
from torch import nn
from .transformer import TransformerEncoder, TransformerEncoderLayer
from .transformer import TransformerEncoderLayerLite, TransformerEncoderLite
class Transformer_enc(nn.Module):
def __init__(self, d_model=512, nh... | 4,557 | 38.634783 | 118 | py |
Stark | Stark-main/lib/models/stark/head.py | import torch.nn as nn
import torch
import torch.nn.functional as F
from lib.models.stark.backbone import FrozenBatchNorm2d
from lib.models.stark.repvgg import RepVGGBlock
# import time
def conv(in_planes, out_planes, kernel_size=3, stride=1, padding=1, dilation=1,
freeze_bn=False):
if freeze_bn:
... | 15,638 | 47.268519 | 119 | py |
Stark | Stark-main/lib/models/stark/position_encoding.py | """
Various positional encodings for the transformer.
"""
import math
import torch
from torch import nn
from lib.utils.misc import NestedTensor
class PositionEmbeddingSine(nn.Module):
"""
This is a more standard version of the position embedding, very similar to the one
used by the Attention is all you n... | 5,384 | 37.191489 | 117 | py |
Stark | Stark-main/lib/models/stark/backbone.py | """
Backbone modules.
"""
import torch
import torch.nn.functional as F
from torch import nn
from torchvision.models._utils import IntermediateLayerGetter
from typing import Dict, List
from lib.utils.misc import NestedTensor, is_main_process
from .position_encoding import build_position_encoding
from lib.models.stark i... | 7,601 | 39.010526 | 112 | py |
Stark | Stark-main/lib/models/stark/transformer.py | """
STARK Transformer class.
Copy-paste from torch.nn.Transformer with modifications:
* positional encodings are passed in MHattention
* extra LN at the end of encoder is removed
* decoder returns a stack of activations from all decoding layers
2020.12.23 Split some preprocess fom the forward function
"""... | 19,139 | 39.723404 | 111 | py |
Stark | Stark-main/lib/models/stark/lite_encoder.py | """
(2021.06.27)
Transformer encoder class (Lite version)
-- Only use one layer of encoder
-- search region as queries, "concat" as keys and values
-- only pass the search region to the FFN
-- functions takes standard pytorch Tensor as input (for TensorRT)
"""
from typing import Optional
import torch.nn.functional as F... | 3,351 | 37.528736 | 105 | py |
Stark | Stark-main/lib/models/stark/stark_st.py | """
STARK-ST Model (Spatio-Temporal).
"""
from .backbone import build_backbone
from .transformer import build_transformer
from .head import build_box_head, MLP
from lib.models.stark.stark_s import STARKS
class STARKST(STARKS):
""" This is the base class for Transformer Tracking """
def __init__(self, backbone... | 3,199 | 40.558442 | 123 | py |
Stark | Stark-main/lib/models/stark/stark_s.py | """
Basic STARK Model (Spatial-only).
"""
import torch
from torch import nn
from lib.utils.misc import NestedTensor
from .backbone import build_backbone
from .transformer import build_transformer
from .head import build_box_head
from lib.utils.box_ops import box_xyxy_to_cxcywh
class STARKS(nn.Module):
""" This ... | 5,603 | 42.107692 | 131 | py |
Stark | Stark-main/lib/test/tracker/stark_utils.py | import torch
import numpy as np
from lib.utils.misc import NestedTensor
class Preprocessor(object):
def __init__(self):
self.mean = torch.tensor([0.485, 0.456, 0.406]).view((1, 3, 1, 1)).cuda()
self.std = torch.tensor([0.229, 0.224, 0.225]).view((1, 3, 1, 1)).cuda()
def process(self, img_arr:... | 2,142 | 44.595745 | 100 | py |
Stark | Stark-main/lib/test/tracker/stark_st.py | from lib.test.tracker.basetracker import BaseTracker
import torch
from lib.train.data.processing_utils import sample_target
from copy import deepcopy
# for debug
import cv2
import os
from lib.utils.merge import merge_template_search
from lib.models.stark import build_starkst
from lib.test.tracker.stark_utils import Pre... | 6,546 | 47.139706 | 118 | py |
Stark | Stark-main/lib/test/tracker/stark_s.py | from lib.test.tracker.basetracker import BaseTracker
import torch
from lib.train.data.processing_utils import sample_target
# for debug
import cv2
import os
from lib.utils.merge import merge_template_search
from lib.models.stark import build_starks
from lib.test.tracker.stark_utils import Preprocessor
from lib.utils.bo... | 4,755 | 44.730769 | 118 | py |
Stark | Stark-main/lib/test/tracker/stark_lightning_X_trt.py | from lib.test.tracker.basetracker import BaseTracker
import torch
from lib.train.data.processing_utils import sample_target
# for debug
import cv2
import os
from lib.utils.merge import get_qkv
from lib.models.stark import build_stark_lightning_x_trt
from lib.test.tracker.stark_utils import PreprocessorX
from lib.utils.... | 8,227 | 44.711111 | 118 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.