code stringlengths 17 6.64M |
|---|
def dataloader_msrvtt_test(args, tokenizer, subset='test'):
msrvtt_testset = MSRVTTDataset(subset=subset, anno_path=args.anno_path, video_path=args.video_path, max_words=args.max_words, tokenizer=tokenizer, max_frames=args.max_frames, video_framerate=args.video_framerate, config=args)
try:
test_sample... |
def dataloader_lsmdc_train(args, tokenizer):
lsmdc_dataset = LsmdcDataset(subset='train', anno_path=args.anno_path, video_path=args.video_path, max_words=args.max_words, tokenizer=tokenizer, max_frames=args.max_frames, video_framerate=args.video_framerate, config=args)
train_sampler = torch.utils.data.distrib... |
def dataloader_lsmdc_test(args, tokenizer, subset='test'):
lsmdc_testset = LsmdcDataset(subset=subset, anno_path=args.anno_path, video_path=args.video_path, max_words=args.max_words, tokenizer=tokenizer, max_frames=args.max_frames, video_framerate=args.video_framerate, config=args)
try:
test_sampler =... |
def dataloader_activity_train(args, tokenizer):
activity_dataset = ActivityNetDataset(subset='train', data_path=args.anno_path, features_path=args.video_path, max_words=args.max_words, feature_framerate=args.video_framerate, tokenizer=tokenizer, max_frames=args.max_frames)
train_sampler = torch.utils.data.dis... |
def dataloader_activity_test(args, tokenizer, subset='test'):
activity_testset = ActivityNetDataset(subset=subset, data_path=args.anno_path, features_path=args.video_path, max_words=args.max_words, feature_framerate=args.video_framerate, tokenizer=tokenizer, max_frames=args.max_frames)
try:
test_sampl... |
def dataloader_msvd_train(args, tokenizer):
msvd_dataset = MsvdDataset(subset='train', anno_path=args.anno_path, video_path=args.video_path, max_words=args.max_words, tokenizer=tokenizer, max_frames=args.max_frames, video_framerate=args.video_framerate, config=args)
train_sampler = torch.utils.data.distribute... |
def dataloader_msvd_test(args, tokenizer, subset='test'):
msvd_testset = MsvdDataset(subset=subset, anno_path=args.anno_path, video_path=args.video_path, max_words=args.max_words, tokenizer=tokenizer, max_frames=args.max_frames, video_framerate=args.video_framerate, config=args)
dataloader_msvd = DataLoader(m... |
def dataloader_didemo_train(args, tokenizer):
didemo_dataset = DiDeMoDataset(subset='train', data_path=args.anno_path, features_path=args.video_path, max_words=args.max_words, feature_framerate=args.video_framerate, tokenizer=tokenizer, max_frames=args.max_frames)
train_sampler = torch.utils.data.distributed.... |
def dataloader_didemo_test(args, tokenizer, subset='test'):
didemo_testset = DiDeMoDataset(subset=subset, data_path=args.anno_path, features_path=args.video_path, max_words=args.max_words, feature_framerate=args.video_framerate, tokenizer=tokenizer, max_frames=args.max_frames)
try:
test_sampler = torc... |
class LsmdcDataset(RetrievalDataset):
'LSMDC dataset.'
def __init__(self, subset, anno_path, video_path, tokenizer, max_words=32, max_frames=12, video_framerate=1, image_resolution=224, mode='all', config=None):
super(LsmdcDataset, self).__init__(subset, anno_path, video_path, tokenizer, max_words, m... |
class MSRVTTDataset(RetrievalDataset):
'MSRVTT dataset.'
def __init__(self, subset, anno_path, video_path, tokenizer, max_words=32, max_frames=12, video_framerate=1, image_resolution=224, mode='all', config=None):
super(MSRVTTDataset, self).__init__(subset, anno_path, video_path, tokenizer, max_words... |
class MsvdDataset(RetrievalDataset):
'MSVD dataset loader.'
def __init__(self, subset, anno_path, video_path, tokenizer, max_words=32, max_frames=12, video_framerate=1, image_resolution=224, mode='all', config=None):
super(MsvdDataset, self).__init__(subset, anno_path, video_path, tokenizer, max_word... |
def _interpolation(kwargs):
interpolation = kwargs.pop('resample', Image.BILINEAR)
if isinstance(interpolation, (list, tuple)):
return random.choice(interpolation)
else:
return interpolation
|
def _check_args_tf(kwargs):
if (('fillcolor' in kwargs) and (_PIL_VER < (5, 0))):
kwargs.pop('fillcolor')
kwargs['resample'] = _interpolation(kwargs)
|
def shear_x(img, factor, **kwargs):
_check_args_tf(kwargs)
return img.transform(img.size, Image.AFFINE, (1, factor, 0, 0, 1, 0), **kwargs)
|
def shear_y(img, factor, **kwargs):
_check_args_tf(kwargs)
return img.transform(img.size, Image.AFFINE, (1, 0, 0, factor, 1, 0), **kwargs)
|
def translate_x_rel(img, pct, **kwargs):
pixels = (pct * img.size[0])
_check_args_tf(kwargs)
return img.transform(img.size, Image.AFFINE, (1, 0, pixels, 0, 1, 0), **kwargs)
|
def translate_y_rel(img, pct, **kwargs):
pixels = (pct * img.size[1])
_check_args_tf(kwargs)
return img.transform(img.size, Image.AFFINE, (1, 0, 0, 0, 1, pixels), **kwargs)
|
def translate_x_abs(img, pixels, **kwargs):
_check_args_tf(kwargs)
return img.transform(img.size, Image.AFFINE, (1, 0, pixels, 0, 1, 0), **kwargs)
|
def translate_y_abs(img, pixels, **kwargs):
_check_args_tf(kwargs)
return img.transform(img.size, Image.AFFINE, (1, 0, 0, 0, 1, pixels), **kwargs)
|
def rotate(img, degrees, **kwargs):
_check_args_tf(kwargs)
if (_PIL_VER >= (5, 2)):
return img.rotate(degrees, **kwargs)
elif (_PIL_VER >= (5, 0)):
(w, h) = img.size
post_trans = (0, 0)
rotn_center = ((w / 2.0), (h / 2.0))
angle = (- math.radians(degrees))
m... |
def auto_contrast(img, **__):
return ImageOps.autocontrast(img)
|
def invert(img, **__):
return ImageOps.invert(img)
|
def equalize(img, **__):
return ImageOps.equalize(img)
|
def solarize(img, thresh, **__):
return ImageOps.solarize(img, thresh)
|
def solarize_add(img, add, thresh=128, **__):
lut = []
for i in range(256):
if (i < thresh):
lut.append(min(255, (i + add)))
else:
lut.append(i)
if (img.mode in ('L', 'RGB')):
if ((img.mode == 'RGB') and (len(lut) == 256)):
lut = ((lut + lut) + l... |
def posterize(img, bits_to_keep, **__):
if (bits_to_keep >= 8):
return img
return ImageOps.posterize(img, bits_to_keep)
|
def contrast(img, factor, **__):
return ImageEnhance.Contrast(img).enhance(factor)
|
def color(img, factor, **__):
return ImageEnhance.Color(img).enhance(factor)
|
def brightness(img, factor, **__):
return ImageEnhance.Brightness(img).enhance(factor)
|
def sharpness(img, factor, **__):
return ImageEnhance.Sharpness(img).enhance(factor)
|
def _randomly_negate(v):
'With 50% prob, negate the value'
return ((- v) if (random.random() > 0.5) else v)
|
def _rotate_level_to_arg(level, _hparams):
level = ((level / _MAX_LEVEL) * 30.0)
level = _randomly_negate(level)
return (level,)
|
def _enhance_level_to_arg(level, _hparams):
return ((((level / _MAX_LEVEL) * 1.8) + 0.1),)
|
def _enhance_increasing_level_to_arg(level, _hparams):
level = ((level / _MAX_LEVEL) * 0.9)
level = (1.0 + _randomly_negate(level))
return (level,)
|
def _shear_level_to_arg(level, _hparams):
level = ((level / _MAX_LEVEL) * 0.3)
level = _randomly_negate(level)
return (level,)
|
def _translate_abs_level_to_arg(level, hparams):
translate_const = hparams['translate_const']
level = ((level / _MAX_LEVEL) * float(translate_const))
level = _randomly_negate(level)
return (level,)
|
def _translate_rel_level_to_arg(level, hparams):
translate_pct = hparams.get('translate_pct', 0.45)
level = ((level / _MAX_LEVEL) * translate_pct)
level = _randomly_negate(level)
return (level,)
|
def _posterize_level_to_arg(level, _hparams):
return (int(((level / _MAX_LEVEL) * 4)),)
|
def _posterize_increasing_level_to_arg(level, hparams):
return ((4 - _posterize_level_to_arg(level, hparams)[0]),)
|
def _posterize_original_level_to_arg(level, _hparams):
return ((int(((level / _MAX_LEVEL) * 4)) + 4),)
|
def _solarize_level_to_arg(level, _hparams):
return (int(((level / _MAX_LEVEL) * 256)),)
|
def _solarize_increasing_level_to_arg(level, _hparams):
return ((256 - _solarize_level_to_arg(level, _hparams)[0]),)
|
def _solarize_add_level_to_arg(level, _hparams):
return (int(((level / _MAX_LEVEL) * 110)),)
|
class AugmentOp():
'\n Apply for video.\n '
def __init__(self, name, prob=0.5, magnitude=10, hparams=None):
hparams = (hparams or _HPARAMS_DEFAULT)
self.aug_fn = NAME_TO_OP[name]
self.level_fn = LEVEL_TO_ARG[name]
self.prob = prob
self.magnitude = magnitude
... |
def _select_rand_weights(weight_idx=0, transforms=None):
transforms = (transforms or _RAND_TRANSFORMS)
assert (weight_idx == 0)
rand_weights = _RAND_CHOICE_WEIGHTS_0
probs = [rand_weights[k] for k in transforms]
probs /= np.sum(probs)
return probs
|
def rand_augment_ops(magnitude=10, hparams=None, transforms=None):
hparams = (hparams or _HPARAMS_DEFAULT)
transforms = (transforms or _RAND_TRANSFORMS)
return [AugmentOp(name, prob=0.5, magnitude=magnitude, hparams=hparams) for name in transforms]
|
class RandAugment():
def __init__(self, ops, num_layers=2, choice_weights=None):
self.ops = ops
self.num_layers = num_layers
self.choice_weights = choice_weights
def __call__(self, img):
ops = np.random.choice(self.ops, self.num_layers, replace=(self.choice_weights is None), ... |
def rand_augment_transform(config_str, hparams):
"\n RandAugment: Practical automated data augmentation... - https://arxiv.org/abs/1909.13719\n\n Create a RandAugment transform\n :param config_str: String defining configuration of random augmentation. Consists of multiple sections separated by\n dashe... |
class RawVideoExtractorCV2():
def __init__(self, centercrop=False, size=224, framerate=(- 1), subset='test'):
self.centercrop = centercrop
self.size = size
self.framerate = framerate
self.transform = self._transform(self.size)
self.subset = subset
self.tsfm_dict = ... |
class LayerNorm(nn.LayerNorm):
"Subclass torch's LayerNorm to handle fp16."
def forward(self, x: torch.Tensor):
orig_type = x.dtype
ret = super().forward(x.type(torch.float32))
return ret.type(orig_type)
|
class QuickGELU(nn.Module):
def forward(self, x: torch.Tensor):
return (x * torch.sigmoid((1.702 * x)))
|
class ResidualAttentionBlock(nn.Module):
def __init__(self, d_model: int, n_head: int, attn_mask=None):
super(ResidualAttentionBlock, self).__init__()
self.attn = nn.MultiheadAttention(d_model, n_head)
self.ln_1 = LayerNorm(d_model)
self.mlp = nn.Sequential(OrderedDict([('c_fc', n... |
class Transformer(nn.Module):
def __init__(self, width: int, layers: int, heads: int, attn_mask=None):
super(Transformer, self).__init__()
self.width = width
self.layers = layers
self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads) for _ in range(layers)])
de... |
def warmup_cosine(x, warmup=0.002):
if (x < warmup):
return (x / warmup)
return (0.5 * (1.0 + math.cos((math.pi * x))))
|
def warmup_constant(x, warmup=0.002):
' Linearly increases learning rate over `warmup`*`t_total` (as provided to BertAdam) training steps.\n Learning rate is 1. afterwards. '
if (x < warmup):
return (x / warmup)
return 1.0
|
def warmup_linear(x, warmup=0.002):
' Specifies a triangular learning rate schedule where peak is reached at `warmup`*`t_total`-th (as provided to BertAdam) training step.\n After `t_total`-th training step, learning rate is zero. '
if (x < warmup):
return (x / warmup)
return max(((x - 1.0)... |
class BertAdam(Optimizer):
"Implements BERT version of Adam algorithm with weight decay fix.\n Params:\n lr: learning rate\n warmup: portion of t_total for the warmup, -1 means no warmup. Default: -1\n t_total: total number of training steps for the learning\n rate schedule, -1... |
@lru_cache()
def default_bpe():
return os.path.join(os.path.dirname(os.path.abspath(__file__)), 'bpe_simple_vocab_16e6.txt.gz')
|
@lru_cache()
def bytes_to_unicode():
"\n Returns list of utf-8 byte and a corresponding list of unicode strings.\n The reversible bpe codes work on unicode strings.\n This means you need a large # of unicode characters in your vocab if you want to avoid UNKs.\n When you're at something like a 10B toke... |
def get_pairs(word):
'Return set of symbol pairs in a word.\n Word is represented as tuple of symbols (symbols being variable-length strings).\n '
pairs = set()
prev_char = word[0]
for char in word[1:]:
pairs.add((prev_char, char))
prev_char = char
return pairs
|
def basic_clean(text):
text = ftfy.fix_text(text)
text = html.unescape(html.unescape(text))
return text.strip()
|
def whitespace_clean(text):
text = re.sub('\\s+', ' ', text)
text = text.strip()
return text
|
class SimpleTokenizer(object):
def __init__(self, bpe_path: str=default_bpe()):
self.byte_encoder = bytes_to_unicode()
self.byte_decoder = {v: k for (k, v) in self.byte_encoder.items()}
merges = gzip.open(bpe_path).read().decode('utf-8').split('\n')
merges = merges[1:(((49152 - 25... |
def get_world_size():
if (not dist.is_available()):
return 1
if (not dist.is_initialized()):
return 1
return dist.get_world_size()
|
def get_rank():
if (not dist.is_available()):
return 0
if (not dist.is_initialized()):
return 0
return dist.get_rank()
|
def is_main_process():
return (get_rank() == 0)
|
def synchronize():
'\n Helper function to synchronize (barrier) among all processes when\n using distributed training\n '
if (not dist.is_available()):
return
if (not dist.is_initialized()):
return
world_size = dist.get_world_size()
if (world_size == 1):
return
... |
def all_gather(data):
'\n Run all_gather on arbitrary picklable data (not necessarily tensors)\n Args:\n data: any picklable object\n Returns:\n list[data]: list of data gathered from each rank\n '
world_size = get_world_size()
if (world_size == 1):
return [data]
buff... |
def reduce_dict(input_dict, average=True):
'\n Args:\n input_dict (dict): all the values will be reduced\n average (bool): whether to do average or sum\n Reduce the values in the dictionary from all processes so that process with rank\n 0 has the averaged results. Returns a dict with the sa... |
def setup_logger(name, save_dir, dist_rank, filename='log.txt'):
logger = logging.getLogger(name)
logger.setLevel(logging.ERROR)
if (dist_rank > 0):
return logger
logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler(stream=sys.stdout)
ch.setLevel(logging.DEBUG)
formatter = log... |
class SmoothedValue(object):
'Track a series of values and provide access to smoothed values over a\n window or the global series average.\n '
def __init__(self, window_size=20):
self.deque = deque(maxlen=window_size)
self.series = []
self.total = 0.0
self.count = 0
... |
class MetricLogger(object):
def __init__(self, delimiter='\t'):
self.meters = defaultdict(SmoothedValue)
self.delimiter = delimiter
def update(self, **kwargs):
for (k, v) in kwargs.items():
if isinstance(v, torch.Tensor):
v = v.item()
assert is... |
def load_data_table(table, image_dir, corrupt_images=None):
'Read data table, find corresponding images, filter out corrupt, missing and MCI images, and return the samples as a pandas dataframe.'
print('Loading dataframe for', table)
df = pd.read_csv(table)
print('Found', len(df), 'images in table')
... |
def load_data_table_3T():
'Load the data table for all 3 Tesla images.'
return load_data_table(table_3T, image_dir_3T, corrupt_images_3T)
|
def load_data_table_15T():
'Load the data table for all 1.5 Tesla images.'
return load_data_table(table_15T, image_dir_15T, corrupt_images_15T)
|
def load_data_table_both():
'Load the data tables for all 1.5 Tesla and 3 Tesla images and combine them.'
df_15T = load_data_table(table_15T, image_dir_15T, corrupt_images_15T)
df_3T = load_data_table(table_3T, image_dir_3T, corrupt_images_3T)
df = pd.concat([df_15T, df_3T])
return df
|
def get_image_filepath(df_row, root_dir=''):
'Return the filepath of the image that is described in the row of the data table.'
filedir = os.path.join(df_row['PTID'], df_row['Visit'].replace(' ', ''))
filename = '{}_{}_{}_{}_{}_Warped.nii.gz'.format(df_row['PTID'], df_row['Scan.Date'].replace('/', '-'), d... |
class ADNIDataset(Dataset):
'\n PyTorch dataset that consists of MRI images and labels.\n \n Args:\n filenames (iterable of strings): The filenames fo the MRI images.\n labels (iterable): The labels for the images.\n mask (array): If not None (default), images are masked by multiplyi... |
def print_df_stats(df, df_train, df_val):
'Print some statistics about the patients and images in a dataset.'
headers = ['Images', '-> AD', '-> CN', 'Patients', '-> AD', '-> CN']
def get_stats(df):
df_ad = df[(df['DX'] == 'Dementia')]
df_cn = df[(df['DX'] == 'CN')]
return [len(df)... |
def build_datasets(df, patients_train, patients_val, print_stats=True, normalize=True):
'\n Build PyTorch datasets based on a data table and a patient-wise train-test split.\n \n Args:\n df (pandas dataframe): The data table from ADNI.\n patients_train (iterable of strings): The patients to... |
def build_loaders(train_dataset, val_dataset):
'Build PyTorch data loaders from the datasets.'
train_loader = DataLoader(train_dataset, batch_size=5, shuffle=True, num_workers=multiprocessing.cpu_count(), pin_memory=torch.cuda.is_available())
val_loader = DataLoader(val_dataset, batch_size=5, shuffle=Fals... |
class ClassificationModel3D(nn.Module):
'The model we use in the paper.'
def __init__(self, dropout=0, dropout2=0):
nn.Module.__init__(self)
self.Conv_1 = nn.Conv3d(1, 8, 3)
self.Conv_1_bn = nn.BatchNorm3d(8)
self.Conv_2 = nn.Conv3d(8, 16, 3)
self.Conv_2_bn = nn.BatchN... |
class KorolevModel(nn.Module):
'The model used in Korolev et al. 2017 (https://arxiv.org/abs/1701.06643).'
def __init__(self):
nn.Module.__init__(self)
self.relu = nn.ReLU()
self.conv = nn.Sequential(nn.Conv3d(1, 8, 3), self.relu, nn.Conv3d(8, 8, 3), self.relu, nn.BatchNorm3d(8), nn.M... |
def build_model():
'Build the model as used in the paper, wrap it in a torchsample trainer and move it to cuda.'
net = ClassificationModel3D(dropout=0.8, dropout2=0)
optimizer = torch.optim.Adam(net.parameters(), lr=0.0001)
loss_function = nn.CrossEntropyLoss()
callbacks = []
trainer = torchsa... |
def train_model(trainer, train_loader, val_loader, cuda_device, num_epoch=1):
'Train and evaluate the model via torchsample.'
trainer.fit_loader(train_loader, val_loader=val_loader, num_epoch=num_epoch, verbose=1, cuda_device=cuda_device)
|
def calculate_roc_auc(trainer, val_loader, cuda_device):
y_val_pred = F.softmax(trainer.predict_loader(val_loader, cuda_device=cuda_device)).data.cpu().numpy()
y_val_true = torch.cat([y for (x, y) in val_loader]).numpy()
y_val_true = y_val_true[:len(y_val_pred)]
return roc_auc_score(y_val_true, y_val_... |
class BinaryAccuracyWithLogits(torchsample.metrics.BinaryAccuracy):
'Same as torchsample.metrics.BinaryAccuracy, but applies a sigmoid function to the network output before calculating the accuracy. This is intended to be used in combination with BCEWightLogitsLoss.'
def __call__(self, y_pred, y_true):
... |
class CategoricalAccuracyWithLogits(torchsample.metrics.CategoricalAccuracy):
'Same as torchsample.metrics.CategoricalAccuracy, but applies a softmax function to the network output before calculating the accuracy. This is intended to be used in combination with CrossEntropyLoss.'
def __call__(self, y_pred, y... |
def start_instance():
print('Starting new instance')
tag = str(int(time.time()))
config_name = ((('clone_' + tag) + '_') + 'spotty.yaml')
shutil.copyfile('spotty.yaml', config_name)
os.system(((("sed -i 's/instancename/" + tag) + "/g' ") + config_name))
os.system(('spotty start -c ' + config_n... |
def download_rico(tmp_path='tmp', dataset_path='rico'):
if (not os.path.exists(tmp_path)):
os.makedirs(tmp_path)
output_path = os.path.join(tmp_path, 'unique_uis.tar.gz')
urllib.request.urlretrieve(DATASET_RICO_URL, output_path)
extract_path = os.path.join(tmp_path, 'extract')
cmd = ['7z',... |
def download_vins(tmp_path='tmp', dataset_path='vins'):
if (not os.path.exists(tmp_path)):
os.makedirs(tmp_path)
gdown.download(DATASET_VINS_URL, output=os.path.join(tmp_path, 'VINS Dataset.zip'), fuzzy=True, use_cookies=False)
extract_path = os.path.join(tmp_path, 'extract')
cmd = ['7z', 'x',... |
def download_boxes_gdown(tmp_path='tmp', dataset_path='webui-boxes'):
if (not os.path.exists(tmp_path)):
os.makedirs(tmp_path)
gdown.download(DATASET_BOXES_URL, output=os.path.join(tmp_path, 'all_boxes.zip'), fuzzy=True, use_cookies=False)
extract_path = os.path.join(tmp_path, 'extract')
cmd =... |
def download_enrico(tmp_path='tmp', dataset_path='enrico', screenclassification_metadata_path='../metadata/screenclassification'):
if (not os.path.exists(tmp_path)):
os.makedirs(tmp_path)
output_path = os.path.join(tmp_path, 'screenshots.zip')
urllib.request.urlretrieve(DATASET_ENRICO_URL, output_... |
def download_metadata_gdown(metadata_key, metadata_path='../metadata'):
if (not os.path.exists(metadata_path)):
os.makedirs(metadata_path)
gdown.download_folder(METADATA_GDRIVE_URLS[metadata_key], output=os.path.join(metadata_path, metadata_key), use_cookies=False)
|
def download_dataset_gdown(dataset_key, tmp_path='tmp', dataset_path='ds'):
if (not os.path.exists(tmp_path)):
os.makedirs(tmp_path)
if (not os.path.exists(os.path.join(tmp_path, dataset_key))):
gdown.download_folder(DATASET_GDRIVE_URLS[dataset_key], output=os.path.join(tmp_path, dataset_key),... |
def download_model_gdown(model_name, model_key, model_path='checkpoints'):
if (not os.path.exists(model_path)):
os.makedirs(model_path)
gdown.download(MODEL_GDRIVE_URLS[model_name][model_key], output=os.path.join(model_path, model_key), fuzzy=True, use_cookies=False)
|
def makeOneHotVec(idx, num_classes):
vec = [(1 if (i == idx) else 0) for i in range(num_classes)]
return vec
|
def collate_fn_silver(batch):
res = defaultdict(list)
for d in batch:
for (k, v) in d.items():
res[k].append(v)
res['label'] = torch.tensor(res['label'], dtype=torch.long)
return res
|
def collate_fn_silver_multi(batch):
res = defaultdict(list)
for d in batch:
for (k, v) in d.items():
res[k].append(v)
res['label'] = torch.stack(res['label'], dim=0)
return res
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.