code stringlengths 17 6.64M |
|---|
def patch_llama_for_linear_scaled_rotary_embeddings(model, scale):
from .LlamaLinearScaledRotaryEmbedding import LlamaLinearScaledRotaryEmbedding
for each in model.model.layers:
each.self_attn.rotary_emb = LlamaLinearScaledRotaryEmbedding(each.self_attn.head_dim, scale=scale, device=each.self_attn.rotary_emb.inv_freq.device)
|
def patch_llama_for_part_ntk_scaled_rotary_embeddings(model, scale):
from .LlamaPartNTKScaledRotaryEmbedding import LlamaPartNTKScaledRotaryEmbedding
for each in model.model.layers:
each.self_attn.rotary_emb = LlamaPartNTKScaledRotaryEmbedding(each.self_attn.head_dim, scale=scale, device=each.self_attn.rotary_emb.inv_freq.device)
|
def patch_llama_for_yarn_scaled_rotary_embeddings(model, scale, original_max_position_embeddings):
from .LlamaYaRNScaledRotaryEmbedding import LlamaYaRNScaledRotaryEmbedding
for each in model.model.layers:
each.self_attn.rotary_emb = LlamaYaRNScaledRotaryEmbedding(each.self_attn.head_dim, scale=scale, original_max_position_embeddings=original_max_position_embeddings, device=each.self_attn.rotary_emb.inv_freq.device)
|
def patch_gptneox_for_scaled_rotary_embeddings(model):
from .GPTNeoXDynamicScaledRotaryEmbedding import GPTNeoXDynamicScaledRotaryEmbedding
for each in model.gpt_neox.layers:
each.attention.rotary_emb = GPTNeoXDynamicScaledRotaryEmbedding(each.attention.rotary_ndims, model.config.max_position_embeddings, device=each.attention.rotary_emb.inv_freq.device)
|
def patch_gptneox_for_ntk_scaled_rotary_embeddings(model, alpha):
from .GPTNeoXNTKScaledRotaryEmbedding import GPTNeoXNTKScaledRotaryEmbedding
for each in model.gpt_neox.layers:
each.attention.rotary_emb = GPTNeoXNTKScaledRotaryEmbedding(each.attention.rotary_ndims, model.config.max_position_embeddings, alpha=alpha, device=each.attention.rotary_emb.inv_freq.device)
|
def patch_gptneox_for_longer_sequences(model, max_positions):
for each in model.gpt_neox.layers:
each.attention.bias = torch.tril(torch.ones((max_positions, max_positions), dtype=each.attention.bias.dtype, device=each.attention.bias.device)).view(1, 1, max_positions, max_positions)
|
def patch_llama_for_rerope(model, training_length, window):
from .LlamaReRoPE import forward_with_rerope
for each in model.model.layers:
def forward(*args, **kwargs):
return forward_with_rerope(each.self_attn, *args, **kwargs)
each.self_attn.training_length = int(training_length)
each.self_attn.window = int(window)
|
def main(args):
if ((args.dataset is None) or (len(args.dataset[0]) == 0)):
raise RuntimeError('No datasets provided')
datasets = args.dataset[0]
splits = [(x.split(',')[1] if (len(x.split(',')) == 2) else '') for x in datasets]
datasets = [x.split(',')[0] for x in datasets]
tokenizer = AutoTokenizer.from_pretrained(args.tokenizer)
if args.json:
dataset = load_dataset('json', data_files=datasets)[args.split]
if reduce((lambda x, y: (x or (len(y) > 0))), splits, False):
if (len(datasets) > 1):
raise RuntimeError('Can only use splitting on json datasets if there is exactly one input file')
dataset = dataset.train_test_split(train_size=float(splits[0]), seed=args.seed)['train']
else:
to_concatenate = []
for i in range(0, len(datasets)):
try:
loaded = load_from_disk(datasets[i])
except:
loaded = load_dataset([i])[args.split]
if (len(splits[i]) > 0):
loaded = loaded.train_test_split(train_size=float(splits[i]), seed=args.seed)['train']
to_concatenate.append(loaded)
dataset = concatenate_datasets(to_concatenate)
dataset = dataset.remove_columns([x for x in dataset.column_names if (x not in [args.feature])])
tokenized_dataset = dataset.map((lambda example: tokenizer([(t + tokenizer.eos_token) for t in example[args.feature]])), batched=True, num_proc=args.num_proc, remove_columns=[args.feature])
block_size = args.sequence_length
def group_texts(examples):
concatenated_examples = {k: list(chain(*examples[k])) for k in examples.keys()}
total_length = len(concatenated_examples[list(examples.keys())[0]])
if (total_length >= block_size):
total_length = ((total_length // block_size) * block_size)
result = {k: [t[i:(i + block_size)] for i in range(0, total_length, block_size)] for (k, t) in concatenated_examples.items()}
return result
train_dataset = tokenized_dataset.map(group_texts, batched=True, num_proc=args.num_proc)
if args.output:
train_dataset.save_to_disk(args.output)
if args.push_to_hub:
train_dataset.push_to_hub(args.push_to_hub, private=True)
|
def main(args):
dataset = load_dataset(args.dataset, split='train')
def truncate(sample):
sample['input_ids'] = sample['input_ids'][0:args.truncate]
sample['labels'] = sample['labels'][0:args.truncate]
sample['attention_mask'] = sample['attention_mask'][0:args.truncate]
return sample
dataset = dataset.map(truncate, desc='Truncating', num_proc=args.num_proc)
dataset.save_to_disk(args.output)
|
class SimCLR(nn.Module):
'Simple SIMCLR implementation.'
def __init__(self, base_network_output_size, nce_logits_output_size, classifier_output_size):
'SimCLR model.\n\n :param base_network_output_size: output-size of resnet50 embedding\n :param nce_logits_output_size: output-size to use for NCE loss\n :param classifier_output_size: number of classes in classifier problem\n :returns: SimCLR object\n :rtype: nn.Module\n\n '
super(SimCLR, self).__init__()
self.base_network_output_size = base_network_output_size
model_fn = models.__dict__[args.arch]
self.base_network = nn.Sequential(*list(model_fn(pretrained=False).children())[:(- 1)])
self.head = nn.Sequential(nn.Linear(base_network_output_size, args.head_latent_size), nn.BatchNorm1d(args.head_latent_size), nn.ReLU(), nn.Linear(args.head_latent_size, nce_logits_output_size), nn.BatchNorm1d(nce_logits_output_size))
self.linear_classifier = nn.Linear(base_network_output_size, classifier_output_size)
def forward(self, augmentation1, augmentation2):
'Returns the NCE logits and the linear predictions.'
representation1 = self.base_network(augmentation1).view((- 1), self.base_network_output_size)
representation2 = self.base_network(augmentation2).view((- 1), self.base_network_output_size)
logits_for_nce1 = self.head(representation1)
logits_for_nce2 = self.head(representation2)
repr_to_classifier = (torch.cat([representation1, representation2], 0) if self.training else representation1)
linear_preds = self.linear_classifier(repr_to_classifier.clone().detach())
return (logits_for_nce1, logits_for_nce2, linear_preds)
|
def build_lr_schedule(optimizer, last_epoch=(- 1)):
' adds a lr scheduler to the optimizer.\n\n :param optimizer: nn.Optimizer\n :returns: scheduler\n :rtype: optim.lr_scheduler\n\n '
if (args.lr_update_schedule == 'fixed'):
sched = optim.lr_scheduler.LambdaLR(optimizer, (lambda epoch: 1.0), last_epoch=last_epoch)
elif (args.lr_update_schedule == 'cosine'):
total_epochs = (args.epochs - args.warmup)
sched = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=total_epochs, last_epoch=last_epoch)
else:
raise NotImplementedError('lr scheduler {} not implemented'.format(args.lr_update_schedule))
if (args.warmup > 0):
warmup = scheduler.LinearWarmup(optimizer, warmup_steps=args.warmup, last_epoch=last_epoch)
sched = scheduler.Scheduler(sched, warmup)
return sched
|
def build_optimizer(model, last_epoch=(- 1)):
' helper to build the optimizer and wrap model\n\n :param model: the model to wrap\n :returns: optimizer wrapping model provided\n :rtype: nn.Optim\n\n '
optim_map = {'rmsprop': optim.RMSprop, 'adam': optim.Adam, 'adadelta': optim.Adadelta, 'sgd': optim.SGD, 'momentum': functools.partial(optim.SGD, momentum=0.9), 'lbfgs': optim.LBFGS}
params_to_optimize = layers.add_weight_decay(model, args.weight_decay)
full_opt_name = args.optimizer.lower().strip()
is_lars = ('lars' in full_opt_name)
if (full_opt_name == 'lamb'):
assert args.half, 'Need fp16 precision to use Apex FusedLAMB.'
optim_map['lamb'] = optimizers.fused_lamb.FusedLAMB
opt_name = (full_opt_name.split('_')[(- 1)] if is_lars else full_opt_name)
print('using {} optimizer {} lars.'.format(opt_name, ('with' if is_lars else 'without')))
lr = args.lr
if (opt_name in ['momentum', 'sgd']):
lr = (args.lr * ((args.batch_size * args.num_replicas) / 256))
opt = optim_map[opt_name](params_to_optimize, lr=lr)
if is_lars:
opt = LARS(opt, eps=0.0)
sched = build_lr_schedule(opt, last_epoch=last_epoch)
return (opt, sched)
|
def build_train_and_test_transforms():
'Returns torchvision OR nvidia-dali transforms.\n\n :returns: train_transforms, test_transforms\n :rtype: list, list\n\n '
resize_shape = (args.image_size_override, args.image_size_override)
if ('dali' in args.task):
import nvidia.dali.ops as ops
import nvidia.dali.types as types
from datasets.dali_imagefolder import ColorJitter, RandomHorizontalFlip, RandomGrayScale
train_transform = [ops.RandomResizedCrop(device=('gpu' if args.cuda else 'cpu'), size=resize_shape, random_area=(0.08, 1.0), random_aspect_ratio=((3.0 / 4), (4.0 / 3))), RandomHorizontalFlip(prob=0.2, cuda=args.cuda), ColorJitter(brightness=(0.8 * args.color_jitter_strength), contrast=(0.8 * args.color_jitter_strength), saturation=(0.2 * args.color_jitter_strength), hue=(0.2 * args.color_jitter_strength), prob=0.8, cuda=args.cuda), RandomGrayScale(prob=0.2, cuda=args.cuda)]
test_transform = [ops.Resize(resize_x=resize_shape[0], resize_y=resize_shape[1], device=('gpu' if args.cuda else 'cpu'), image_type=types.RGB, interp_type=types.INTERP_LINEAR)]
else:
from datasets.utils import GaussianBlur
train_transform = [transforms.RandomResizedCrop((args.image_size_override, args.image_size_override)), transforms.RandomHorizontalFlip(p=0.5), transforms.RandomApply([transforms.ColorJitter(brightness=(0.8 * args.color_jitter_strength), contrast=(0.8 * args.color_jitter_strength), saturation=(0.8 * args.color_jitter_strength), hue=(0.2 * args.color_jitter_strength))], p=0.8), transforms.RandomGrayscale(p=0.2), GaussianBlur(kernel_size=int((0.1 * args.image_size_override)), p=0.5)]
test_transform = [transforms.Resize(resize_shape)]
return (train_transform, test_transform)
|
def build_loader_model_grapher(args):
'builds a model, a dataloader and a grapher\n\n :param args: argparse\n :param transform: the dataloader transform\n :returns: a dataloader, a grapher and a model\n :rtype: list\n\n '
(train_transform, test_transform) = build_train_and_test_transforms()
loader_dict = {'train_transform': train_transform, 'test_transform': test_transform, **vars(args)}
loader = get_loader(**loader_dict)
args.input_shape = loader.input_shape
args.num_train_samples = (loader.num_train_samples // args.num_replicas)
args.num_test_samples = loader.num_test_samples
args.num_valid_samples = (loader.num_valid_samples // args.num_replicas)
args.steps_per_train_epoch = (args.num_train_samples // args.batch_size)
args.total_train_steps = (args.epochs * args.steps_per_train_epoch)
network = SimCLR(base_network_output_size=args.representation_size, nce_logits_output_size=args.nce_size, classifier_output_size=loader.output_size)
network = (nn.SyncBatchNorm.convert_sync_batchnorm(network) if args.convert_to_sync_bn else network)
network = (network.cuda() if args.cuda else network)
lazy_generate_modules(network, loader.train_loader)
network = layers.init_weights(network, init=args.weight_initialization)
if (args.num_replicas > 1):
print('wrapping model with DDP...')
network = layers.DistributedDataParallelPassthrough(network, device_ids=[0], output_device=0, find_unused_parameters=True)
print(network)
print('model has {} million parameters.'.format((utils.number_of_parameters(network) / 1000000.0)))
grapher = None
if ((args.visdom_url is not None) and (args.distributed_rank == 0)):
grapher = Grapher('visdom', env=utils.get_name(args), server=args.visdom_url, port=args.visdom_port)
elif (args.distributed_rank == 0):
grapher = Grapher('tensorboard', logdir=os.path.join('runs', utils.get_name(args)))
return (loader, network, grapher)
|
def lazy_generate_modules(model, loader):
' A helper to build the modules that are lazily compiled\n\n :param model: the nn.Module\n :param loader: the dataloader\n :returns: None\n :rtype: None\n\n '
model.eval()
for (augmentation1, augmentation2, labels) in loader:
with torch.no_grad():
print('augmentation1 = {} / {} | augmentation2 = {} / {} | labels = {} / {}'.format(augmentation1.shape, augmentation1.dtype, augmentation2.shape, augmentation2.dtype, labels.shape, labels.dtype))
(aug1_min, aug1_max) = (augmentation1.min(), augmentation1.max())
(aug2_min, aug2_max) = (augmentation2.min(), augmentation2.max())
print('aug1 in range [min: {}, max: {}] | aug2 in range [min: {}, max: {}]'.format(aug1_min, aug1_max, aug2_min, aug2_max))
if ((aug1_max > 1.0) or (aug1_min < 0)):
raise ValueError('aug1 max > 1.0 or aug1 min < 0. You probably dont want this.')
if ((aug2_max > 1.0) or (aug2_min < 0)):
raise ValueError('aug2 max > 1.0 or aug2 min < 0. You probably dont want this.')
augmentation1 = (augmentation1.cuda(non_blocking=True) if args.cuda else augmentation1)
augmentation2 = (augmentation2.cuda(non_blocking=True) if args.cuda else augmentation2)
_ = model(augmentation1, augmentation2)
break
if (args.polyak_ema > 0):
layers.polyak_ema_parameters(model, args.polyak_ema)
|
def register_plots(loss, grapher, epoch, prefix='train'):
" Registers line plots with grapher.\n\n :param loss: the dict containing '*_mean' or '*_scalar' values\n :param grapher: the grapher object\n :param epoch: the current epoch\n :param prefix: prefix to append to the plot\n :returns: None\n :rtype: None\n\n "
if ((args.distributed_rank == 0) and (grapher is not None)):
for (k, v) in loss.items():
if isinstance(v, dict):
register_plots(loss[k], grapher, epoch, prefix=prefix)
if (('mean' in k) or ('scalar' in k)):
key_name = '-'.join(k.split('_')[0:(- 1)])
value = (v.item() if (not isinstance(v, (float, np.float32, np.float64))) else v)
grapher.add_scalar('{}_{}'.format(prefix, key_name), value, epoch)
|
def register_images(output_map, grapher, prefix='train'):
" Registers image with grapher. Overwrites the existing image due to space.\n\n :param output_map: the dict containing '*_img' of '*_imgs' as keys\n :param grapher: the grapher object\n :param prefix: prefix to attach to images\n :returns: None\n :rtype: None\n\n "
if ((args.distributed_rank == 0) and (grapher is not None)):
for (k, v) in output_map.items():
if isinstance(v, dict):
register_images(output_map[k], grapher, prefix=prefix)
if (('img' in k) or ('imgs' in k)):
key_name = '-'.join(k.split('_')[0:(- 1)])
img = torchvision.utils.make_grid(v, normalize=True, scale_each=True)
grapher.add_image('{}_{}'.format(prefix, key_name), img.detach(), global_step=0)
|
def _extract_sum_scalars(v1, v2):
'Simple helper to sum values in a struct using dm_tree.'
def chk(c):
'Helper to check if we have a primitive or tensor'
return (not isinstance(c, (int, float, np.int32, np.int64, np.float32, np.float64)))
v1_detached = (v1.detach() if chk(v1) else v1)
v2_detached = (v2.detach() if chk(v2) else v2)
return (v1_detached + v2_detached)
|
def execute_graph(epoch, model, loader, grapher, optimizer=None, prefix='test'):
" execute the graph; wphen 'train' is in the name the model runs the optimizer\n\n :param epoch: the current epoch number\n :param model: the torch model\n :param loader: the train or **TEST** loader\n :param grapher: the graph writing helper (eg: visdom / tf wrapper)\n :param optimizer: the optimizer\n :param prefix: 'train', 'test' or 'valid'\n :returns: dictionary with scalars\n :rtype: dict\n\n "
start_time = time.time()
is_eval = ('train' not in prefix)
(model.eval() if is_eval else model.train())
assert ((optimizer is None) if is_eval else (optimizer is not None))
(loss_map, num_samples) = ({}, 0)
objective = NTXent()
for (num_minibatches, (augmentation1, augmentation2, labels)) in enumerate(loader):
augmentation1 = (augmentation1.cuda(non_blocking=True) if args.cuda else augmentation1)
augmentation2 = (augmentation2.cuda(non_blocking=True) if args.cuda else augmentation2)
labels = (labels.cuda(non_blocking=True) if args.cuda else labels)
with (torch.no_grad() if is_eval else utils.dummy_context()):
if (is_eval and (args.polyak_ema > 0)):
(nce_logits1, nce_logits2, linear_preds) = layers.get_polyak_prediction(model, pred_fn=functools.partial(model, augmentation1, augmentation2))
else:
(nce_logits1, nce_logits2, linear_preds) = model(augmentation1, augmentation2)
nce_loss = objective(nce_logits1, nce_logits2, temperature=args.nce_temperature, num_replicas=args.num_replicas)
classifier_labels = (labels if is_eval else torch.cat([labels, labels], 0))
classifier_loss = F.cross_entropy(input=linear_preds, target=classifier_labels)
(acc1, acc5) = metrics.topk(output=linear_preds, target=classifier_labels, topk=(1, 5))
loss_t = {'loss_mean': (nce_loss + classifier_loss), 'nce_loss_mean': nce_loss, 'linear_loss_mean': classifier_loss, 'top1_mean': acc1, 'top5_mean': acc5}
loss_map = (loss_t if (not loss_map) else tree.map_structure(_extract_sum_scalars, loss_map, loss_t))
num_samples += augmentation1.size(0)
if (not is_eval):
optimizer.zero_grad()
if args.half:
with amp.scale_loss(loss_t['loss_mean'], optimizer) as scaled_loss:
scaled_loss.backward()
else:
loss_t['loss_mean'].backward()
if (args.clip > 0):
nn.utils.clip_grad_value_(model.parameters(), args.clip)
optimizer.step()
if (args.polyak_ema > 0):
layers.polyak_ema_parameters(model, args.polyak_ema)
del loss_t
if args.debug_step:
break
loss_map = tree.map_structure((lambda v: (v / (num_minibatches + 1))), loss_map)
to_log = '{}-{}[Epoch {}][{} samples][{:.2f} sec]:\t Loss: {:.4f}\tTop-1: {:.4f}\tTop-5: {:.4f}'
print(to_log.format(prefix, args.distributed_rank, epoch, num_samples, (time.time() - start_time), loss_map['loss_mean'].item(), loss_map['top1_mean'].item(), loss_map['top5_mean'].item()))
register_plots({**loss_map}, grapher, epoch=epoch, prefix=prefix)
num_images_to_post = min(64, augmentation1.shape[0])
image_size_to_post = min(64, augmentation1.shape[(- 1)])
image_map = {'augmentation1_imgs': F.interpolate(augmentation1[0:num_images_to_post], size=(image_size_to_post, image_size_to_post)), 'augmentation2_imgs': F.interpolate(augmentation2[0:num_images_to_post], size=(image_size_to_post, image_size_to_post))}
register_images({**image_map}, grapher, prefix=prefix)
if (grapher is not None):
grapher.save()
loss_val = loss_map['loss_mean'].detach().item()
loss_map.clear()
return loss_val
|
def train(epoch, model, optimizer, train_loader, grapher, prefix='train'):
' Helper to run execute-graph for the train dataset\n\n :param epoch: the current epoch\n :param model: the model\n :param test_loader: the train data-loader\n :param grapher: the grapher object\n :param prefix: the default prefix; useful if we have multiple training types\n :returns: mean ELBO scalar\n :rtype: float32\n\n '
return execute_graph(epoch, model, train_loader, grapher, optimizer, prefix='train')
|
def test(epoch, model, test_loader, grapher, prefix='test'):
' Helper to run execute-graph for the test dataset\n\n :param epoch: the current epoch\n :param model: the model\n :param test_loader: the test data-loaderpp\n :param grapher: the grapher object\n :param prefix: the default prefix; useful if we have multiple test types\n :returns: mean ELBO scalar\n :rtype: float32\n\n '
return execute_graph(epoch, model, test_loader, grapher, prefix='test')
|
def init_multiprocessing_and_cuda(rank, args_from_spawn):
'Sets the appropriate flags for multi-process jobs.'
if args_from_spawn.multi_gpu_distributed:
os.environ['CUDA_VISIBLE_DEVICES'] = str(rank)
args_from_spawn.distributed_rank = rank
args_from_spawn.cuda = ((not args_from_spawn.no_cuda) and torch.cuda.is_available())
if args_from_spawn.cuda:
torch.backends.cudnn.benchmark = True
print('Replica {} / {} using GPU: {}'.format((rank + 1), args_from_spawn.num_replicas, torch.cuda.get_device_name(0)))
if (args_from_spawn.seed is not None):
print(('setting seed %d' % args_from_spawn.seed))
np.random.seed(args_from_spawn.seed)
torch.manual_seed(args_from_spawn.seed)
if args_from_spawn.cuda:
torch.cuda.manual_seed_all(args_from_spawn.seed)
if (args_from_spawn.num_replicas > 1):
torch.distributed.init_process_group(backend='nccl', init_method=os.environ['MASTER_ADDR'], world_size=args_from_spawn.num_replicas, rank=rank)
print('Successfully created DDP process group!')
args_from_spawn.batch_size = (args_from_spawn.batch_size // args_from_spawn.num_replicas)
global args
args = args_from_spawn
|
def run(rank, args):
' Main entry-point into the program\n\n :param rank: current device rank\n :param args: argparse\n :returns: None\n :rtype: None\n\n '
init_multiprocessing_and_cuda(rank, args)
(loader, model, grapher) = build_loader_model_grapher(args)
print(pprint.PrettyPrinter(indent=4).pformat(vars(args)))
(optimizer, scheduler) = build_optimizer(model)
if args.half:
(model, optimizer) = amp.initialize(model, optimizer, opt_level='O2')
model = layers.append_save_and_load_fns(model, optimizer, scheduler, grapher, args)
saver = layers.ModelSaver(model, early_stop=args.early_stop, rank=args.distributed_rank, burn_in_interval=int((0.1 * args.epochs)), larger_is_better=False, max_early_stop_steps=10)
restore_dict = saver.restore()
init_epoch = restore_dict['epoch']
for epoch in range(init_epoch, (args.epochs + 1)):
train(epoch, model, optimizer, loader.train_loader, grapher)
test_loss = test(epoch, model, loader.test_loader, grapher)
loader.set_all_epochs(epoch)
scheduler.step()
register_plots({'learning_rate_scalar': optimizer.param_groups[0]['lr']}, grapher, epoch)
if saver(test_loss):
saver.restore()
test_loss = test(epoch, model, loader.test_loader, grapher)
break
if ((epoch == 2) and (args.distributed_rank == 0)):
config_to_post = vars(args)
slurm_id = utils.get_slurm_id()
if (slurm_id is not None):
config_to_post['slurm_job_id'] = slurm_id
grapher.add_text('config', pprint.PrettyPrinter(indent=4).pformat(config_to_post), 0)
if (grapher is not None):
grapher.close()
|
def l2_normalize(x, dim=None, eps=1e-12):
'Normalize a tensor over dim using the L2-norm.'
sq_sum = torch.sum(torch.square(x), dim=dim, keepdim=True)
inv_norm = torch.rsqrt(torch.max(sq_sum, (torch.ones_like(sq_sum) * eps)))
return (x * inv_norm)
|
def all_gather(tensor, expand_dim=0, num_replicas=None):
'Gathers a tensor from other replicas, concat on expand_dim and return.'
num_replicas = (dist.get_world_size() if (num_replicas is None) else num_replicas)
other_replica_tensors = [torch.zeros_like(tensor) for _ in range(num_replicas)]
dist.all_gather(other_replica_tensors, tensor)
return torch.cat([o.unsqueeze(expand_dim) for o in other_replica_tensors], expand_dim)
|
class NTXent(nn.Module):
'Wrap a module to get self.training member.'
def __init__(self):
super(NTXent, self).__init__()
def forward(self, embedding1, embedding2, temperature=0.1, num_replicas=None):
'NT-XENT Loss from SimCLR\n\n :param embedding1: embedding of augmentation1\n :param embedding2: embedding of augmentation2\n :param temperature: nce normalization temp\n :param num_replicas: number of compute devices\n :returns: scalar loss\n :rtype: float32\n\n '
batch_size = embedding1.shape[0]
feature_size = embedding1.shape[(- 1)]
num_replicas = (dist.get_world_size() if (num_replicas is None) else num_replicas)
LARGE_NUM = 1000000000.0
embedding1 = l2_normalize(embedding1, dim=(- 1))
embedding2 = l2_normalize(embedding2, dim=(- 1))
if ((num_replicas > 1) and self.training):
embedding1_full = all_gather(embedding1, num_replicas=num_replicas)
embedding2_full = all_gather(embedding2, num_replicas=num_replicas)
embedding1_full = embedding1_full.reshape((- 1), feature_size)
embedding2_full = embedding2_full.reshape((- 1), feature_size)
replica_id = dist.get_rank()
labels = (torch.arange(batch_size, device=embedding1.device) + (replica_id * batch_size))
labels = labels.type(torch.int64)
full_batch_size = embedding1_full.shape[0]
masks = F.one_hot(labels, full_batch_size).to(embedding1_full.device)
labels = F.one_hot(labels, (full_batch_size * 2)).to(embedding1_full.device)
else:
embedding1_full = embedding1
embedding2_full = embedding2
masks = F.one_hot(torch.arange(batch_size), batch_size).to(embedding1.device)
labels = F.one_hot(torch.arange(batch_size), (batch_size * 2)).to(embedding1.device)
logits_aa = (torch.matmul(embedding1, embedding1_full.T) / temperature)
logits_aa = (logits_aa - (masks * LARGE_NUM))
logits_bb = (torch.matmul(embedding2, embedding2_full.T) / temperature)
logits_bb = (logits_bb - (masks * LARGE_NUM))
logits_ab = (torch.matmul(embedding1, embedding2_full.T) / temperature)
logits_ba = (torch.matmul(embedding2, embedding1_full.T) / temperature)
loss_a = F.cross_entropy(input=torch.cat([logits_ab, logits_aa], 1), target=torch.argmax(labels, (- 1)), reduction='none')
loss_b = F.cross_entropy(input=torch.cat([logits_ba, logits_bb], 1), target=torch.argmax(labels, (- 1)), reduction='none')
loss = (loss_a + loss_b)
return torch.mean(loss)
|
class LARS(Optimizer):
"Implements 'LARS (Layer-wise Adaptive Rate Scaling)'__ as Optimizer a\n :class:`~torch.optim.Optimizer` wrapper.\n\n __ : https://arxiv.org/abs/1708.03888\n\n Wraps an arbitrary optimizer like :class:`torch.optim.SGD` to use LARS. If\n you want to the same performance obtained with small-batch training when\n you use large-batch training, LARS will be helpful::\n\n Args:\n optimizer (Optimizer):\n optimizer to wrap\n eps (float, optional):\n epsilon to help with numerical stability while calculating the\n adaptive learning rate\n trust_coef (float, optional):\n trust coefficient for calculating the adaptive learning rate\n\n Example::\n base_optimizer = optim.SGD(model.parameters(), lr=0.1)\n optimizer = LARS(optimizer=base_optimizer)\n\n output = model(input)\n loss = loss_fn(output, target)\n loss.backward()\n\n optimizer.step()\n\n "
def __init__(self, optimizer, eps=1e-08, trust_coef=0.001):
if (eps < 0.0):
raise ValueError(('invalid epsilon value: , %f' % eps))
if (trust_coef < 0.0):
raise ValueError(('invalid trust coefficient: %f' % trust_coef))
self.optim = optimizer
self.eps = eps
self.trust_coef = trust_coef
def __getstate__(self):
lars_dict = {}
lars_dict['eps'] = self.eps
lars_dict['trust_coef'] = self.trust_coef
return (self.optim, lars_dict)
def __setstate__(self, state):
(self.optim, lars_dict) = state
self.eps = lars_dict['eps']
self.trust_coef = lars_dict['trust_coef']
def __repr__(self):
return ('%s(%r)' % (self.__class__.__name__, self.optim))
@property
def param_groups(self):
return self.optim.param_groups
@property
def state(self):
return self.optim.state
def state_dict(self):
return self.optim.state_dict()
def load_state_dict(self, state_dict):
self.optim.load_state_dict(state_dict)
def zero_grad(self):
self.optim.zero_grad()
def add_param_group(self, param_group):
self.optim.add_param_group(param_group)
def apply_adaptive_lrs(self):
with torch.no_grad():
for group in self.optim.param_groups:
weight_decay = group['weight_decay']
ignore = group.get('ignore', None)
for p in group['params']:
if (p.grad is None):
continue
if (weight_decay > 0):
p.grad = p.grad.add(p, alpha=weight_decay)
if ((ignore is not None) and (not ignore)):
param_norm = p.norm()
grad_norm = p.grad.norm()
adaptive_lr = 1.0
if ((param_norm > 0) and (grad_norm > 0)):
adaptive_lr = ((self.trust_coef * param_norm) / (grad_norm + self.eps))
p.grad = p.grad.mul(adaptive_lr)
def step(self, *args, **kwargs):
self.apply_adaptive_lrs()
weight_decay_orig = [group['weight_decay'] for group in self.optim.param_groups]
for group in self.optim.param_groups:
group['weight_decay'] = 0
loss = self.optim.step(*args, **kwargs)
for (group, wo) in zip(self.optim.param_groups, weight_decay_orig):
group['weight_decay'] = wo
return loss
|
class Scheduler(object):
'Simple container for warmup and normal scheduler.'
def __init__(self, normal_schededuler, warmup_scheduler=None):
self.warmup = warmup_scheduler
self.sched = normal_schededuler
def get_last_lr(self):
' Return last computed learning rate by current scheduler.'
if ((self.warmup is not None) and (not self.warmup.complete)):
return self.warmup.get_last_lr()
return self.sched.get_last_lr()
def state_dict(self):
'Returns the state of each scheduler as a :class:`dict`.'
state_dict = {'warmup': (self.warmup.state_dict() if (self.warmup is not None) else {}), 'sched': self.sched.state_dict()}
return state_dict
def load_state_dict(self, state_dict):
'Loads the schedulers state.\n\n Arguments:\n state_dict (dict): scheduler state. Should be an object returned\n from a call to :meth:`state_dict`.\n '
if self.warmup:
self.warmup.load_state_dict(state_dict['warmup'])
self.sched.load_state_dict(state_dict['sched'])
def step(self, *args, **kwargs):
if ((self.warmup is not None) and (not self.warmup.complete)):
return self.warmup.step(*args, **kwargs)
return self.sched.step(*args, **kwargs)
|
class LinearWarmup(LambdaLR):
' Linear warmup and then constant.\n Linearly increases learning rate schedule from 0 to 1 over `warmup_steps` training steps.\n Keeps learning rate schedule equal to 1. after warmup_steps.\n\n From https://bit.ly/39o2W1f\n '
def __init__(self, optimizer, warmup_steps, last_epoch=(- 1)):
self.warmup_steps = warmup_steps
self.complete = False
super(LinearWarmup, self).__init__(optimizer, self.lr_lambda, last_epoch=last_epoch)
def lr_lambda(self, step):
if (step < self.warmup_steps):
return (float(step) / float(max(1.0, self.warmup_steps)))
self.complete = True
return 1.0
|
class ProgressLogger(Callback):
def __init__(self, metric_monitor: dict, precision: int=3):
self.metric_monitor = metric_monitor
self.precision = precision
def on_train_start(self, trainer: Trainer, pl_module: LightningModule, **kwargs) -> None:
logger.info('Training started')
def on_train_end(self, trainer: Trainer, pl_module: LightningModule, **kwargs) -> None:
logger.info('Training done')
def on_validation_epoch_end(self, trainer: Trainer, pl_module: LightningModule, **kwargs) -> None:
if trainer.sanity_checking:
logger.info('Sanity checking ok.')
def on_train_epoch_end(self, trainer: Trainer, pl_module: LightningModule, padding=False, **kwargs) -> None:
metric_format = f'{{:.{self.precision}e}}'
line = f'Epoch {trainer.current_epoch}'
if padding:
line = f"{line:>{len('Epoch xxxx')}}"
metrics_str = []
losses_dict = trainer.callback_metrics
for (metric_name, dico_name) in self.metric_monitor.items():
if (dico_name in losses_dict):
metric = losses_dict[dico_name].item()
metric = metric_format.format(metric)
metric = f'{metric_name} {metric}'
metrics_str.append(metric)
if (len(metrics_str) == 0):
return
memory = f'Memory {psutil.virtual_memory().percent}%'
line = ((((line + ': ') + ' '.join(metrics_str)) + ' ') + memory)
logger.info(line)
|
def get_module_config(cfg_model, path='modules'):
files = os.listdir(f'./configs/{path}/')
for file in files:
if file.endswith('.yaml'):
with open((f'./configs/{path}/' + file), 'r') as f:
cfg_model.merge_with(OmegaConf.load(f))
return cfg_model
|
def get_obj_from_str(string, reload=False):
(module, cls) = string.rsplit('.', 1)
if reload:
module_imp = importlib.import_module(module)
importlib.reload(module_imp)
return getattr(importlib.import_module(module, package=None), cls)
|
def instantiate_from_config(config):
if (not ('target' in config)):
if (config == '__is_first_stage__'):
return None
elif (config == '__is_unconditional__'):
return None
raise KeyError('Expected key `target` to instantiate.')
return get_obj_from_str(config['target'])(**config.get('params', dict()))
|
def parse_args(phase='train'):
parser = ArgumentParser()
group = parser.add_argument_group('Training options')
if (phase in ['train', 'test', 'demo']):
group.add_argument('--cfg', type=str, required=False, default='./configs/config.yaml', help='config file')
group.add_argument('--cfg_assets', type=str, required=False, default='./configs/assets.yaml', help='config file for asset paths')
group.add_argument('--batch_size', type=int, required=False, help='training batch size')
group.add_argument('--device', type=int, nargs='+', required=False, help='training device')
group.add_argument('--nodebug', action='store_true', required=False, help='debug or not')
group.add_argument('--dir', type=str, required=False, help='evaluate existing npys')
if (phase == 'demo'):
group.add_argument('--render', action='store_true', help='Render visulizaed figures')
group.add_argument('--render_mode', type=str, help='video or sequence')
group.add_argument('--frame_rate', type=float, default=12.5, help='the frame rate for the input/output motion')
group.add_argument('--replication', type=int, default=1, help='the frame rate for the input/output motion')
group.add_argument('--example', type=str, required=False, help='input text and lengths with txt format')
group.add_argument('--task', type=str, required=False, help='random_sampling, reconstrucion or text_motion')
group.add_argument('--out_dir', type=str, required=False, help='output dir')
group.add_argument('--allinone', action='store_true', required=False, help='output seperate or combined npy file')
if (phase == 'render'):
group.add_argument('--cfg', type=str, required=False, default='./configs/render.yaml', help='config file')
group.add_argument('--cfg_assets', type=str, required=False, default='./configs/assets.yaml', help='config file for asset paths')
group.add_argument('--npy', type=str, required=False, default=None, help='npy motion files')
group.add_argument('--dir', type=str, required=False, default=None, help='npy motion folder')
group.add_argument('--mode', type=str, required=False, default='sequence', help='render target: video, sequence, frame')
group.add_argument('--joint_type', type=str, required=False, default=None, help='mmm or vertices for skeleton')
params = parser.parse_args()
cfg_base = OmegaConf.load('./configs/base.yaml')
cfg_exp = OmegaConf.merge(cfg_base, OmegaConf.load(params.cfg))
cfg_model = get_module_config(cfg_exp.model, cfg_exp.model.target)
cfg_assets = OmegaConf.load(params.cfg_assets)
cfg = OmegaConf.merge(cfg_exp, cfg_model, cfg_assets)
if (phase in ['train', 'test']):
cfg.TRAIN.BATCH_SIZE = (params.batch_size if params.batch_size else cfg.TRAIN.BATCH_SIZE)
cfg.DEVICE = (params.device if params.device else cfg.DEVICE)
cfg.DEBUG = ((not params.nodebug) if (params.nodebug is not None) else cfg.DEBUG)
cfg.DEBUG = (False if (phase == 'test') else cfg.DEBUG)
if (phase == 'test'):
cfg.DEBUG = False
cfg.DEVICE = [0]
print('Force no debugging and one gpu when testing')
cfg.TEST.TEST_DIR = (params.dir if params.dir else cfg.TEST.TEST_DIR)
if (phase == 'demo'):
cfg.DEMO.RENDER = params.render
cfg.DEMO.FRAME_RATE = params.frame_rate
cfg.DEMO.EXAMPLE = params.example
cfg.DEMO.TASK = params.task
cfg.TEST.FOLDER = (params.out_dir if params.dir else cfg.TEST.FOLDER)
cfg.DEMO.REPLICATION = params.replication
cfg.DEMO.OUTALL = params.allinone
if (phase == 'render'):
if params.npy:
cfg.RENDER.NPY = params.npy
cfg.RENDER.INPUT_MODE = 'npy'
if params.dir:
cfg.RENDER.DIR = params.dir
cfg.RENDER.INPUT_MODE = 'dir'
cfg.RENDER.JOINT_TYPE = params.joint_type
cfg.RENDER.MODE = params.mode
if cfg.DEBUG:
cfg.NAME = ('debug--' + cfg.NAME)
cfg.LOGGER.WANDB.OFFLINE = True
cfg.LOGGER.VAL_EVERY_STEPS = 1
return cfg
|
class HumanML3DDataModule(BASEDataModule):
def __init__(self, cfg, batch_size, num_workers, collate_fn=None, phase='train', **kwargs):
super().__init__(batch_size=batch_size, num_workers=num_workers, collate_fn=collate_fn)
self.save_hyperparameters(logger=False)
self.name = 'humanml3d'
self.njoints = 22
if (phase == 'text_only'):
self.Dataset = TextOnlyDataset
else:
self.Dataset = Text2MotionDatasetV2
self.cfg = cfg
sample_overrides = {'split': 'val', 'tiny': True, 'progress_bar': False}
self._sample_set = self.get_sample_set(overrides=sample_overrides)
self.nfeats = self._sample_set.nfeats
def feats2joints(self, features):
mean = torch.tensor(self.hparams.mean).to(features)
std = torch.tensor(self.hparams.std).to(features)
features = ((features * std) + mean)
return recover_from_ric(features, self.njoints)
def joints2feats(self, features):
features = process_file(features, self.njoints)[0]
return features
def renorm4t2m(self, features):
ori_mean = torch.tensor(self.hparams.mean).to(features)
ori_std = torch.tensor(self.hparams.std).to(features)
eval_mean = torch.tensor(self.hparams.mean_eval).to(features)
eval_std = torch.tensor(self.hparams.std_eval).to(features)
features = ((features * ori_std) + ori_mean)
features = ((features - eval_mean) / eval_std)
return features
def mm_mode(self, mm_on=True):
if mm_on:
self.is_mm = True
self.name_list = self.test_dataset.name_list
self.mm_list = np.random.choice(self.name_list, self.cfg.TEST.MM_NUM_SAMPLES, replace=False)
self.test_dataset.name_list = self.mm_list
else:
self.is_mm = False
self.test_dataset.name_list = self.name_list
|
class Humanact12DataModule(BASEDataModule):
def __init__(self, cfg, batch_size, num_workers, collate_fn=None, phase='train', **kwargs):
super().__init__(batch_size=batch_size, num_workers=num_workers, collate_fn=collate_fn)
self.save_hyperparameters(logger=False)
self.name = 'HumanAct12'
self.Dataset = HumanAct12Poses
self.cfg = cfg
sample_overrides = {'num_seq_max': 2, 'split': 'test', 'tiny': True, 'progress_bar': False}
self.nfeats = 150
self.njoints = 25
self.nclasses = 12
|
class KitDataModule(BASEDataModule):
def __init__(self, cfg, phase='train', collate_fn=all_collate, batch_size: int=32, num_workers: int=16, **kwargs):
super().__init__(batch_size=batch_size, num_workers=num_workers, collate_fn=collate_fn)
self.save_hyperparameters(logger=False)
self.name = 'kit'
self.njoints = 21
if (phase == 'text_only'):
self.Dataset = TextOnlyDataset
else:
self.Dataset = Text2MotionDatasetV2
self.cfg = cfg
sample_overrides = {'split': 'val', 'tiny': True, 'progress_bar': False}
self._sample_set = self.get_sample_set(overrides=sample_overrides)
self.nfeats = self._sample_set.nfeats
def feats2joints(self, features):
mean = torch.tensor(self.hparams.mean).to(features)
std = torch.tensor(self.hparams.std).to(features)
features = ((features * std) + mean)
return recover_from_ric(features, self.njoints)
def renorm4t2m(self, features):
ori_mean = torch.tensor(self.hparams.mean).to(features)
ori_std = torch.tensor(self.hparams.std).to(features)
eval_mean = torch.tensor(self.hparams.mean_eval).to(features)
eval_std = torch.tensor(self.hparams.std_eval).to(features)
features = ((features * ori_std) + ori_mean)
features = ((features - eval_mean) / eval_std)
return features
def mm_mode(self, mm_on=True):
if mm_on:
self.is_mm = True
self.name_list = self.test_dataset.name_list
self.mm_list = np.random.choice(self.name_list, self.cfg.TEST.MM_NUM_SAMPLES, replace=False)
self.test_dataset.name_list = self.mm_list
else:
self.is_mm = False
self.test_dataset.name_list = self.name_list
|
class UestcDataModule(BASEDataModule):
def __init__(self, cfg, batch_size, num_workers, collate_fn=None, method_name='vibe', phase='train', **kwargs):
super().__init__(batch_size=batch_size, num_workers=num_workers, collate_fn=collate_fn)
self.save_hyperparameters(logger=False)
self.name = 'Uestc'
self.Dataset = UESTC
self.cfg = cfg
self.nfeats = 150
self.njoints = 25
self.nclasses = 40
|
class HumanAct12Poses(Dataset):
dataname = 'humanact12'
def __init__(self, datapath='data/HumanAct12Poses', **kargs):
self.datapath = datapath
super().__init__(**kargs)
pkldatafilepath = os.path.join(datapath, 'humanact12poses.pkl')
with rich.progress.open(pkldatafilepath, 'rb', description='loading humanact12 pkl') as f:
data = pkl.load(f)
self._pose = [x for x in data['poses']]
self._num_frames_in_video = [p.shape[0] for p in self._pose]
self._joints = [x for x in data['joints3D']]
self._actions = [x for x in data['y']]
total_num_actions = 12
self.num_classes = total_num_actions
self._train = list(range(len(self._pose)))
keep_actions = np.arange(0, total_num_actions)
self._action_to_label = {x: i for (i, x) in enumerate(keep_actions)}
self._label_to_action = {i: x for (i, x) in enumerate(keep_actions)}
self._action_classes = humanact12_coarse_action_enumerator
def _load_joints3D(self, ind, frame_ix):
return self._joints[ind][frame_ix]
def _load_rotvec(self, ind, frame_ix):
pose = self._pose[ind][frame_ix].reshape((- 1), 24, 3)
return pose
|
def parse_info_name(path):
name = os.path.splitext(os.path.split(path)[(- 1)])[0]
info = {}
current_letter = None
for letter in name:
if (letter in string.ascii_letters):
info[letter] = []
current_letter = letter
else:
info[current_letter].append(letter)
for key in info.keys():
info[key] = ''.join(info[key])
return info
|
def to_numpy(tensor):
if torch.is_tensor(tensor):
return tensor.cpu().numpy()
elif (type(tensor).__module__ != 'numpy'):
raise ValueError('Cannot convert {} to numpy array'.format(type(tensor)))
return tensor
|
def to_torch(ndarray):
if (type(ndarray).__module__ == 'numpy'):
return torch.from_numpy(ndarray)
elif (not torch.is_tensor(ndarray)):
raise ValueError('Cannot convert {} to torch tensor'.format(type(ndarray)))
return ndarray
|
def cleanexit():
import sys
import os
try:
sys.exit(0)
except SystemExit:
os._exit(0)
|
def lengths_to_mask(lengths):
max_len = max(lengths)
mask = (torch.arange(max_len, device=lengths.device).expand(len(lengths), max_len) < lengths.unsqueeze(1))
return mask
|
def collate_tensors(batch):
dims = batch[0].dim()
max_size = [max([b.size(i) for b in batch]) for i in range(dims)]
size = ((len(batch),) + tuple(max_size))
canvas = batch[0].new_zeros(size=size)
for (i, b) in enumerate(batch):
sub_tensor = canvas[i]
for d in range(dims):
sub_tensor = sub_tensor.narrow(d, 0, b.size(d))
sub_tensor.add_(b)
return canvas
|
def collate(batch):
databatch = [b[0] for b in batch]
labelbatch = [b[1] for b in batch]
lenbatch = [len(b[0][0][0]) for b in batch]
databatchTensor = collate_tensors(databatch)
labelbatchTensor = torch.as_tensor(labelbatch)
lenbatchTensor = torch.as_tensor(lenbatch)
maskbatchTensor = lengths_to_mask(lenbatchTensor)
batch = {'x': databatchTensor, 'y': labelbatchTensor, 'mask': maskbatchTensor, 'lengths': lenbatchTensor}
return batch
|
class BASEDataModule(pl.LightningDataModule):
def __init__(self, collate_fn, batch_size: int, num_workers: int):
super().__init__()
self.dataloader_options = {'batch_size': batch_size, 'num_workers': num_workers, 'collate_fn': collate_fn}
self.persistent_workers = True
self.is_mm = False
def get_sample_set(self, overrides={}):
sample_params = self.hparams.copy()
sample_params.update(overrides)
split_file = pjoin(eval(f'self.cfg.DATASET.{self.name.upper()}.SPLIT_ROOT'), (self.cfg.EVAL.SPLIT + '.txt'))
return self.Dataset(split_file=split_file, **sample_params)
def __getattr__(self, item):
if (item.endswith('_dataset') and (not item.startswith('_'))):
subset = item[:(- len('_dataset'))]
item_c = ('_' + item)
if (item_c not in self.__dict__):
subset = (subset.upper() if (subset != 'val') else 'EVAL')
split = eval(f'self.cfg.{subset}.SPLIT')
split_file = pjoin(eval(f'self.cfg.DATASET.{self.name.upper()}.SPLIT_ROOT'), (eval(f'self.cfg.{subset}.SPLIT') + '.txt'))
self.__dict__[item_c] = self.Dataset(split_file=split_file, split=split, **self.hparams)
return getattr(self, item_c)
classname = self.__class__.__name__
raise AttributeError(f"'{classname}' object has no attribute '{item}'")
def setup(self, stage=None):
self.stage = stage
if (stage in (None, 'fit')):
_ = self.train_dataset
_ = self.val_dataset
if (stage in (None, 'test')):
_ = self.test_dataset
def train_dataloader(self):
return DataLoader(self.train_dataset, shuffle=True, persistent_workers=True, **self.dataloader_options)
def predict_dataloader(self):
dataloader_options = self.dataloader_options.copy()
dataloader_options['batch_size'] = (1 if self.is_mm else self.cfg.TEST.BATCH_SIZE)
dataloader_options['num_workers'] = self.cfg.TEST.NUM_WORKERS
dataloader_options['shuffle'] = False
return DataLoader(self.test_dataset, persistent_workers=True, **dataloader_options)
def val_dataloader(self):
dataloader_options = self.dataloader_options.copy()
dataloader_options['batch_size'] = self.cfg.EVAL.BATCH_SIZE
dataloader_options['num_workers'] = self.cfg.EVAL.NUM_WORKERS
dataloader_options['shuffle'] = False
return DataLoader(self.val_dataset, persistent_workers=True, **dataloader_options)
def test_dataloader(self):
dataloader_options = self.dataloader_options.copy()
dataloader_options['batch_size'] = (1 if self.is_mm else self.cfg.TEST.BATCH_SIZE)
dataloader_options['num_workers'] = self.cfg.TEST.NUM_WORKERS
dataloader_options['shuffle'] = False
return DataLoader(self.test_dataset, persistent_workers=True, **dataloader_options)
|
def get_mean_std(phase, cfg, dataset_name):
name = ('t2m' if (dataset_name == 'humanml3d') else dataset_name)
assert (name in ['t2m', 'kit'])
if (phase in ['val']):
if (name == 't2m'):
data_root = pjoin(cfg.model.t2m_path, name, 'Comp_v6_KLD01', 'meta')
elif (name == 'kit'):
data_root = pjoin(cfg.model.t2m_path, name, 'Comp_v6_KLD005', 'meta')
else:
raise ValueError('Only support t2m and kit')
mean = np.load(pjoin(data_root, 'mean.npy'))
std = np.load(pjoin(data_root, 'std.npy'))
else:
data_root = eval(f'cfg.DATASET.{dataset_name.upper()}.ROOT')
mean = np.load(pjoin(data_root, 'Mean.npy'))
std = np.load(pjoin(data_root, 'Std.npy'))
return (mean, std)
|
def get_WordVectorizer(cfg, phase, dataset_name):
if (phase not in ['text_only']):
if (dataset_name.lower() in ['humanml3d', 'kit']):
return WordVectorizer(cfg.DATASET.WORD_VERTILIZER_PATH, 'our_vab')
else:
raise ValueError('Only support WordVectorizer for HumanML3D')
else:
return None
|
def get_collate_fn(name, phase='train'):
if (name.lower() in ['humanml3d', 'kit']):
return mld_collate
elif (name.lower() in ['humanact12', 'uestc']):
return a2m_collate
|
def get_datasets(cfg, logger=None, phase='train'):
dataset_names = eval(f'cfg.{phase.upper()}.DATASETS')
datasets = []
for dataset_name in dataset_names:
if (dataset_name.lower() in ['humanml3d', 'kit']):
data_root = eval(f'cfg.DATASET.{dataset_name.upper()}.ROOT')
(mean, std) = get_mean_std(phase, cfg, dataset_name)
(mean_eval, std_eval) = get_mean_std('val', cfg, dataset_name)
wordVectorizer = get_WordVectorizer(cfg, phase, dataset_name)
collate_fn = get_collate_fn(dataset_name, phase)
if (dataset_name.lower() in ['kit']):
dataset = dataset_module_map[dataset_name.lower()](cfg=cfg, batch_size=cfg.TRAIN.BATCH_SIZE, num_workers=cfg.TRAIN.NUM_WORKERS, debug=cfg.DEBUG, collate_fn=collate_fn, mean=mean, std=std, mean_eval=mean_eval, std_eval=std_eval, w_vectorizer=wordVectorizer, text_dir=pjoin(data_root, 'texts'), motion_dir=pjoin(data_root, motion_subdir[dataset_name]), max_motion_length=cfg.DATASET.SAMPLER.MAX_LEN, min_motion_length=24, max_text_len=cfg.DATASET.SAMPLER.MAX_TEXT_LEN, unit_length=eval(f'cfg.DATASET.{dataset_name.upper()}.UNIT_LEN'))
datasets.append(dataset)
else:
dataset = dataset_module_map[dataset_name.lower()](cfg=cfg, batch_size=cfg.TRAIN.BATCH_SIZE, num_workers=cfg.TRAIN.NUM_WORKERS, debug=cfg.DEBUG, collate_fn=collate_fn, mean=mean, std=std, mean_eval=mean_eval, std_eval=std_eval, w_vectorizer=wordVectorizer, text_dir=pjoin(data_root, 'texts'), motion_dir=pjoin(data_root, motion_subdir[dataset_name]), max_motion_length=cfg.DATASET.SAMPLER.MAX_LEN, min_motion_length=cfg.DATASET.SAMPLER.MIN_LEN, max_text_len=cfg.DATASET.SAMPLER.MAX_TEXT_LEN, unit_length=eval(f'cfg.DATASET.{dataset_name.upper()}.UNIT_LEN'))
datasets.append(dataset)
elif (dataset_name.lower() in ['humanact12', 'uestc']):
collate_fn = get_collate_fn(dataset_name, phase)
dataset = dataset_module_map[dataset_name.lower()](datapath=eval(f'cfg.DATASET.{dataset_name.upper()}.ROOT'), cfg=cfg, batch_size=cfg.TRAIN.BATCH_SIZE, num_workers=cfg.TRAIN.NUM_WORKERS, debug=cfg.DEBUG, collate_fn=collate_fn, num_frames=cfg.DATASET.HUMANACT12.NUM_FRAMES, sampling=cfg.DATASET.SAMPLER.SAMPLING, sampling_step=cfg.DATASET.SAMPLER.SAMPLING_STEP, pose_rep=cfg.DATASET.HUMANACT12.POSE_REP, max_len=cfg.DATASET.SAMPLER.MAX_LEN, min_len=cfg.DATASET.SAMPLER.MIN_LEN, num_seq_max=(cfg.DATASET.SAMPLER.MAX_SQE if (not cfg.DEBUG) else 100), glob=cfg.DATASET.HUMANACT12.GLOB, translation=cfg.DATASET.HUMANACT12.TRANSLATION)
cfg.DATASET.NCLASSES = dataset.nclasses
datasets.append(dataset)
elif (dataset_name.lower() in ['amass']):
raise NotImplementedError
else:
raise NotImplementedError
cfg.DATASET.NFEATS = datasets[0].nfeats
cfg.DATASET.NJOINTS = datasets[0].njoints
return datasets
|
def is_float(numStr):
flag = False
numStr = str(numStr).strip().lstrip('-').lstrip('+')
try:
reg = re.compile('^[-+]?[0-9]+\\.[0-9]+$')
res = reg.match(str(numStr))
if res:
flag = True
except Exception as ex:
print(('is_float() - error: ' + str(ex)))
return flag
|
def is_number(numStr):
flag = False
numStr = str(numStr).strip().lstrip('-').lstrip('+')
if str(numStr).isdigit():
flag = True
return flag
|
def get_opt(opt_path, device):
opt = Namespace()
opt_dict = vars(opt)
skip = ('-------------- End ----------------', '------------ Options -------------', '\n')
print('Reading', opt_path)
with open(opt_path) as f:
for line in f:
if (line.strip() not in skip):
(key, value) = line.strip().split(': ')
if (value in ('True', 'False')):
opt_dict[key] = bool(value)
elif is_float(value):
opt_dict[key] = float(value)
elif is_number(value):
opt_dict[key] = int(value)
else:
opt_dict[key] = str(value)
opt_dict['which_epoch'] = 'latest'
opt.save_root = pjoin(opt.checkpoints_dir, opt.dataset_name, opt.name)
opt.model_dir = pjoin(opt.save_root, 'model')
opt.meta_dir = pjoin(opt.save_root, 'meta')
if (opt.dataset_name == 't2m'):
opt.data_root = './dataset/HumanML3D'
opt.motion_dir = pjoin(opt.data_root, 'new_joint_vecs')
opt.text_dir = pjoin(opt.data_root, 'texts')
opt.joints_num = 22
opt.dim_pose = 263
opt.max_motion_length = 196
elif (opt.dataset_name == 'kit'):
opt.data_root = './dataset/KIT-ML'
opt.motion_dir = pjoin(opt.data_root, 'new_joint_vecs')
opt.text_dir = pjoin(opt.data_root, 'texts')
opt.joints_num = 21
opt.dim_pose = 251
opt.max_motion_length = 196
else:
raise KeyError('Dataset not recognized')
opt.dim_word = 300
opt.num_classes = (200 // opt.unit_length)
opt.dim_pos_ohot = len(POS_enumerator)
opt.is_train = False
opt.is_continue = False
opt.device = device
return opt
|
def save_json(save_path, data):
with open(save_path, 'w') as file:
json.dump(data, file)
|
def load_json(file_path):
with open(file_path, 'r') as file:
data = json.load(file)
return data
|
def process(graph):
(entities, relations) = ({}, [])
for i in graph['verbs']:
description = i['description']
pos = 0
flag = 0
(_words, _spans) = ([], [])
for i in description.split():
(tags, verb) = ({}, 0)
if ('[' in i):
_role = i[1:(- 1)]
flag = 1
_spans = [pos]
_words = []
elif (']' in i):
_words.append(i[:(- 1)])
entities[len(entities)] = {'role': _role, 'spans': _spans, 'words': _words}
pos += 1
flag = 0
if (_role != 'V'):
tags[len(entities)] = _role
else:
verb = len(entities)
else:
pos += 1
if flag:
_words.append(i)
_spans.append(pos)
for i in tags:
relations.append((verb, i, tags[i]))
output = {'entities': entities, 'relations': relations}
return output
|
class WordVectorizer(object):
def __init__(self, meta_root, prefix):
vectors = np.load(pjoin(meta_root, ('%s_data.npy' % prefix)))
words = pickle.load(open(pjoin(meta_root, ('%s_words.pkl' % prefix)), 'rb'))
word2idx = pickle.load(open(pjoin(meta_root, ('%s_idx.pkl' % prefix)), 'rb'))
self.word2vec = {w: vectors[word2idx[w]] for w in words}
def _get_pos_ohot(self, pos):
pos_vec = np.zeros(len(POS_enumerator))
if (pos in POS_enumerator):
pos_vec[POS_enumerator[pos]] = 1
else:
pos_vec[POS_enumerator['OTHER']] = 1
return pos_vec
def __len__(self):
return len(self.word2vec)
def __getitem__(self, item):
(word, pos) = item.split('/')
if (word in self.word2vec):
word_vec = self.word2vec[word]
vip_pos = None
for (key, values) in VIP_dict.items():
if (word in values):
vip_pos = key
break
if (vip_pos is not None):
pos_vec = self._get_pos_ohot(vip_pos)
else:
pos_vec = self._get_pos_ohot(pos)
else:
word_vec = self.word2vec['unk']
pos_vec = self._get_pos_ohot('OTHER')
return (word_vec, pos_vec)
|
class FrameSampler():
def __init__(self, sampling='conseq', sampling_step=1, request_frames=None, threshold_reject=0.75, max_len=1000, min_len=10):
self.sampling = sampling
self.sampling_step = sampling_step
self.request_frames = request_frames
self.threshold_reject = threshold_reject
self.max_len = max_len
self.min_len = min_len
def __call__(self, num_frames):
return get_frameix_from_data_index(num_frames, self.request_frames, self.sampling, self.sampling_step)
def accept(self, duration):
if (self.request_frames is None):
if (duration > self.max_len):
return False
elif (duration < self.min_len):
return False
else:
min_number = (self.threshold_reject * self.request_frames)
if (duration < min_number):
return False
return True
def get(self, key, default=None):
return getattr(self, key, default)
def __getitem__(self, key):
return getattr(self, key)
|
def subsample(num_frames, last_framerate, new_framerate):
step = int((last_framerate / new_framerate))
assert (step >= 1)
frames = np.arange(0, num_frames, step)
return frames
|
def upsample(motion, last_framerate, new_framerate):
step = int((new_framerate / last_framerate))
assert (step >= 1)
alpha = np.linspace(0, 1, (step + 1))
last = np.einsum('l,...->l...', (1 - alpha), motion[:(- 1)])
new = np.einsum('l,...->l...', alpha, motion[1:])
chuncks = (last + new)[:(- 1)]
output = np.concatenate(chuncks.swapaxes(1, 0))
output = np.concatenate((output, motion[[(- 1)]]))
return output
|
def get_frameix_from_data_index(num_frames: int, request_frames: Optional[int], sampling: str='conseq', sampling_step: int=1) -> Array:
nframes = num_frames
if (request_frames is None):
frame_ix = np.arange(nframes)
elif (request_frames > nframes):
fair = False
if fair:
choices = np.random.choice(range(nframes), request_frames, replace=True)
frame_ix = sorted(choices)
else:
ntoadd = max(0, (request_frames - nframes))
lastframe = (nframes - 1)
padding = (lastframe * np.ones(ntoadd, dtype=int))
frame_ix = np.concatenate((np.arange(0, nframes), padding))
elif (sampling in ['conseq', 'random_conseq']):
step_max = ((nframes - 1) // (request_frames - 1))
if (sampling == 'conseq'):
if ((sampling_step == (- 1)) or ((sampling_step * (request_frames - 1)) >= nframes)):
step = step_max
else:
step = sampling_step
elif (sampling == 'random_conseq'):
step = random.randint(1, step_max)
lastone = (step * (request_frames - 1))
shift_max = ((nframes - lastone) - 1)
shift = random.randint(0, max(0, (shift_max - 1)))
frame_ix = (shift + np.arange(0, (lastone + 1), step))
elif (sampling == 'random'):
choices = np.random.choice(range(nframes), request_frames, replace=False)
frame_ix = sorted(choices)
else:
raise ValueError('Sampling not recognized.')
return frame_ix
|
def lengths_to_mask(lengths):
max_len = max(lengths)
mask = (torch.arange(max_len, device=lengths.device).expand(len(lengths), max_len) < lengths.unsqueeze(1))
return mask
|
def collate_tensors(batch):
dims = batch[0].dim()
max_size = [max([b.size(i) for b in batch]) for i in range(dims)]
size = ((len(batch),) + tuple(max_size))
canvas = batch[0].new_zeros(size=size)
for (i, b) in enumerate(batch):
sub_tensor = canvas[i]
for d in range(dims):
sub_tensor = sub_tensor.narrow(d, 0, b.size(d))
sub_tensor.add_(b)
return canvas
|
def all_collate(batch):
notnone_batches = [b for b in batch if (b is not None)]
databatch = [b['motion'] for b in notnone_batches]
if ('lengths' in notnone_batches[0]):
lenbatch = [b['lengths'] for b in notnone_batches]
else:
lenbatch = [len(b['inp'][0][0]) for b in notnone_batches]
databatchTensor = collate_tensors(databatch)
lenbatchTensor = torch.as_tensor(lenbatch)
maskbatchTensor = lengths_to_mask(lenbatchTensor, databatchTensor.shape[(- 1)]).unsqueeze(1).unsqueeze(1)
motion = databatchTensor
cond = {'y': {'mask': maskbatchTensor, 'lengths': lenbatchTensor}}
if ('text' in notnone_batches[0]):
textbatch = [b['text'] for b in notnone_batches]
cond['y'].update({'text': textbatch})
if ('action_text' in notnone_batches[0]):
action_text = [b['action_text'] for b in notnone_batches]
cond['y'].update({'action_text': action_text})
return (motion, cond)
|
def mld_collate(batch):
notnone_batches = [b for b in batch if (b is not None)]
notnone_batches.sort(key=(lambda x: x[3]), reverse=True)
adapted_batch = {'motion': collate_tensors([torch.tensor(b[4]).float() for b in notnone_batches]), 'text': [b[2] for b in notnone_batches], 'length': [b[5] for b in notnone_batches], 'word_embs': collate_tensors([torch.tensor(b[0]).float() for b in notnone_batches]), 'pos_ohot': collate_tensors([torch.tensor(b[1]).float() for b in notnone_batches]), 'text_len': collate_tensors([torch.tensor(b[3]) for b in notnone_batches]), 'tokens': [b[6] for b in notnone_batches], 'V': [b[7] for b in notnone_batches], 'entities': [b[8] for b in notnone_batches], 'relations': [b[9] for b in notnone_batches]}
return adapted_batch
|
def a2m_collate(batch):
databatch = [b[0] for b in batch]
labelbatch = [b[1] for b in batch]
lenbatch = [len(b[0][0][0]) for b in batch]
labeltextbatch = [b[3] for b in batch]
databatchTensor = collate_tensors(databatch)
labelbatchTensor = torch.as_tensor(labelbatch).unsqueeze(1)
lenbatchTensor = torch.as_tensor(lenbatch)
maskbatchTensor = lengths_to_mask(lenbatchTensor)
adapted_batch = {'motion': databatchTensor.permute(0, 3, 2, 1).flatten(start_dim=2), 'action': labelbatchTensor, 'action_text': labeltextbatch, 'mask': maskbatchTensor, 'length': lenbatchTensor}
return adapted_batch
|
def parse_args(self, args=None, namespace=None):
if (args is not None):
return self.parse_args_bak(args=args, namespace=namespace)
try:
idx = sys.argv.index('--')
args = sys.argv[(idx + 1):]
except ValueError as e:
args = []
return self.parse_args_bak(args=args, namespace=namespace)
|
def code_path(path=''):
code_dir = hydra.utils.get_original_cwd()
code_dir = Path(code_dir)
return str((code_dir / path))
|
def working_path(path):
return str((Path(os.getcwd()) / path))
|
def generate_id():
return ID
|
def get_last_checkpoint(path, ckpt_name='last.ckpt'):
output_dir = Path(hydra.utils.to_absolute_path(path))
last_ckpt_path = ((output_dir / 'checkpoints') / ckpt_name)
return str(last_ckpt_path)
|
def get_kitname(load_amass_data: bool, load_with_rot: bool):
if (not load_amass_data):
return 'kit-mmm-xyz'
if (load_amass_data and (not load_with_rot)):
return 'kit-amass-xyz'
if (load_amass_data and load_with_rot):
return 'kit-amass-rot'
|
def resolve_cfg_path(cfg: DictConfig):
working_dir = os.getcwd()
cfg.working_dir = working_dir
|
class ActorVae(nn.Module):
def __init__(self, ablation, nfeats: int, latent_dim: list=[1, 256], ff_size: int=1024, num_layers: int=9, num_heads: int=4, dropout: float=0.1, is_vae: bool=True, activation: str='gelu', position_embedding: str='learned', **kwargs) -> None:
super().__init__()
self.latent_size = latent_dim[0]
self.latent_dim = latent_dim[(- 1)]
self.is_vae = is_vae
input_feats = nfeats
output_feats = nfeats
self.encoder = ActorAgnosticEncoder(nfeats=input_feats, vae=True, latent_dim=self.latent_dim, ff_size=ff_size, num_layers=num_layers, num_heads=num_heads, dropout=dropout, activation=activation, **kwargs)
self.decoder = ActorAgnosticDecoder(nfeats=output_feats, vae=True, latent_dim=self.latent_dim, ff_size=ff_size, num_layers=num_layers, num_heads=num_heads, dropout=dropout, activation=activation, **kwargs)
def forward(self, features: Tensor, lengths: Optional[List[int]]=None):
print('Should Not enter here')
(z, dist) = self.encode(features, lengths)
feats_rst = self.decode(z, lengths)
return (feats_rst, z, dist)
def encode(self, features: Tensor, lengths: Optional[List[int]]=None) -> Union[(Tensor, Distribution)]:
dist = self.encoder(features, lengths)
if self.is_vae:
latent = sample_from_distribution(dist)
else:
latent = dist.unsqueeze(0)
return (latent, dist)
def decode(self, z: Tensor, lengths: List[int]):
feats = self.decoder(z, lengths)
return feats
|
class ActorAgnosticEncoder(nn.Module):
def __init__(self, nfeats: int, vae: bool, latent_dim: int=256, ff_size: int=1024, num_layers: int=4, num_heads: int=4, dropout: float=0.1, activation: str='gelu', **kwargs) -> None:
super().__init__()
input_feats = nfeats
self.vae = vae
self.skel_embedding = nn.Linear(input_feats, latent_dim)
if vae:
self.mu_token = nn.Parameter(torch.randn(latent_dim))
self.logvar_token = nn.Parameter(torch.randn(latent_dim))
else:
self.emb_token = nn.Parameter(torch.randn(latent_dim))
self.sequence_pos_encoding = PositionalEncoding(latent_dim, dropout)
seq_trans_encoder_layer = nn.TransformerEncoderLayer(d_model=latent_dim, nhead=num_heads, dim_feedforward=ff_size, dropout=dropout, activation=activation)
self.seqTransEncoder = nn.TransformerEncoder(seq_trans_encoder_layer, num_layers=num_layers)
def forward(self, features: Tensor, lengths: Optional[List[int]]=None) -> Union[(Tensor, Distribution)]:
if (lengths is None):
lengths = [len(feature) for feature in features]
device = features.device
(bs, nframes, nfeats) = features.shape
mask = lengths_to_mask(lengths, device)
x = features
x = self.skel_embedding(x)
x = x.permute(1, 0, 2)
if self.vae:
mu_token = torch.tile(self.mu_token, (bs,)).reshape(bs, (- 1))
logvar_token = torch.tile(self.logvar_token, (bs,)).reshape(bs, (- 1))
xseq = torch.cat((mu_token[None], logvar_token[None], x), 0)
token_mask = torch.ones((bs, 2), dtype=bool, device=x.device)
aug_mask = torch.cat((token_mask, mask), 1)
else:
emb_token = torch.tile(self.emb_token, (bs,)).reshape(bs, (- 1))
xseq = torch.cat((emb_token[None], x), 0)
token_mask = torch.ones((bs, 1), dtype=bool, device=x.device)
aug_mask = torch.cat((token_mask, mask), 1)
xseq = self.sequence_pos_encoding(xseq)
final = self.seqTransEncoder(xseq, src_key_padding_mask=(~ aug_mask))
if self.vae:
(mu, logvar) = (final[0], final[1])
std = logvar.exp().pow(0.5)
dist = torch.distributions.Normal(mu, std)
return dist
else:
return final[0]
|
class ActorAgnosticDecoder(nn.Module):
def __init__(self, nfeats: int, latent_dim: int=256, ff_size: int=1024, num_layers: int=4, num_heads: int=4, dropout: float=0.1, activation: str='gelu', **kwargs) -> None:
super().__init__()
output_feats = nfeats
self.latent_dim = latent_dim
self.nfeats = nfeats
self.sequence_pos_encoding = PositionalEncoding(latent_dim, dropout)
seq_trans_decoder_layer = nn.TransformerDecoderLayer(d_model=latent_dim, nhead=num_heads, dim_feedforward=ff_size, dropout=dropout, activation=activation)
self.seqTransDecoder = nn.TransformerDecoder(seq_trans_decoder_layer, num_layers=num_layers)
self.final_layer = nn.Linear(latent_dim, output_feats)
def forward(self, z: Tensor, lengths: List[int]):
mask = lengths_to_mask(lengths, z.device)
(bs, nframes) = mask.shape
nfeats = self.nfeats
time_queries = torch.zeros(nframes, bs, self.latent_dim, device=z.device)
time_queries = self.sequence_pos_encoding(time_queries)
output = self.seqTransDecoder(tgt=time_queries, memory=z, tgt_key_padding_mask=(~ mask))
output = self.final_layer(output)
output[(~ mask.T)] = 0
feats = output.permute(1, 0, 2)
return feats
|
def sample_from_distribution(dist, *, fact=1.0, sample_mean=False) -> Tensor:
if sample_mean:
return dist.loc.unsqueeze(0)
if (fact is None):
return dist.rsample().unsqueeze(0)
eps = (dist.rsample() - dist.loc)
z = (dist.loc + (fact * eps))
z = z.unsqueeze(0)
return z
|
class MLDTextEncoder(nn.Module):
def __init__(self, cfg, modelpath: str, finetune: bool=False, vae: bool=True, latent_dim: int=256, ff_size: int=1024, num_layers: int=6, num_heads: int=4, dropout: float=0.1, activation: str='gelu', **kwargs) -> None:
super().__init__()
from transformers import AutoTokenizer, AutoModel
from transformers import logging
logging.set_verbosity_error()
os.environ['TOKENIZERS_PARALLELISM'] = 'false'
self.tokenizer = AutoTokenizer.from_pretrained(modelpath)
self.text_model = AutoModel.from_pretrained(modelpath)
if (not finetune):
self.text_model.training = False
for p in self.text_model.parameters():
p.requires_grad = False
self.text_encoded_dim = self.text_model.config.hidden_size
self.text_encoded_dim = latent_dim
encoded_dim = self.text_model.config.hidden_size
self.projection = nn.Sequential(nn.ReLU(), nn.Linear(encoded_dim, latent_dim))
vae = False
if vae:
self.mu_token = nn.Parameter(torch.randn(latent_dim))
self.logvar_token = nn.Parameter(torch.randn(latent_dim))
else:
self.global_text_token = nn.Parameter(torch.randn(latent_dim))
self.sequence_pos_encoding = PositionalEncoding(latent_dim, dropout)
seq_trans_encoder_layer = nn.TransformerEncoderLayer(d_model=latent_dim, nhead=num_heads, dim_feedforward=ff_size, dropout=dropout, activation=activation)
self.seqTransEncoder = nn.TransformerEncoder(seq_trans_encoder_layer, num_layers=num_layers)
if self.is_action_branch:
action_trans_encoder_layer = nn.TransformerEncoderLayer(d_model=latent_dim, nhead=num_heads, dim_feedforward=ff_size, dropout=dropout, activation=activation)
self.actionTransEncoder = nn.TransformerEncoder(action_trans_encoder_layer, num_layers=num_layers)
self.mean_token = nn.Parameter(torch.randn(latent_dim))
self.std_token = nn.Parameter(torch.randn(latent_dim))
def global_branch(self, x, mask):
bs = x.shape[0]
x = x.permute(1, 0, 2)
global_tokens = torch.tile(self.global_text_token, (bs,)).reshape(bs, (- 1))
if self.is_cross_token:
mean_tokens = torch.tile(self.mean_token, (bs,)).reshape(bs, (- 1))
std_tokens = torch.tile(self.std_token, (bs,)).reshape(bs, (- 1))
xseq = torch.cat((mean_tokens[None], std_tokens[None], global_tokens[None], x), 0)
token_mask = torch.ones((bs, 3), dtype=bool, device=x.device)
aug_mask = torch.cat((token_mask, mask), 1)
else:
xseq = torch.cat((global_tokens[None], x), 0)
token_mask = torch.ones((bs, 1), dtype=bool, device=x.device)
aug_mask = torch.cat((token_mask, mask), 1)
xseq = self.sequence_pos_encoding(xseq)
text_tokens = self.seqTransEncoder(xseq, src_key_padding_mask=(~ aug_mask))
return text_tokens
def action_branch(self, x, mask):
bs = x.shape[0]
mean_tokens = torch.tile(self.mean_token, (bs,)).reshape(bs, (- 1))
std_tokens = torch.tile(self.std_token, (bs,)).reshape(bs, (- 1))
actionSeq = torch.cat((mean_tokens[None], std_tokens[None], x), 0)
token_mask = torch.ones((bs, 2), dtype=bool, device=x.device)
aug_mask = torch.cat((token_mask, mask), 1)
actionSeq = self.sequence_pos_encoding(actionSeq)
action_tokens = self.actionTransEncoder(actionSeq, src_key_padding_mask=(~ aug_mask))
return action_tokens[0:2]
def forward(self, texts: List[str]):
(text_encoded, mask) = self.get_last_hidden_state(texts, return_mask=True)
text_emb = self.projection(text_encoded)
return text_emb
def get_last_hidden_state(self, texts: List[str], return_mask: bool=False):
encoded_inputs = self.tokenizer(texts, return_tensors='pt', padding=True)
output = self.text_model(**encoded_inputs.to(self.text_model.device))
if (not return_mask):
return output.last_hidden_state
return (output.last_hidden_state, encoded_inputs.attention_mask.to(dtype=bool))
|
class Encoder_FC(nn.Module):
def __init__(self, modeltype, njoints, nfeats, num_frames, num_classes, translation, pose_rep, glob, glob_rot, latent_dim=256, **kargs):
super().__init__()
self.modeltype = modeltype
self.njoints = njoints
self.nfeats = nfeats
self.num_frames = num_frames
self.num_classes = num_classes
self.translation = translation
self.pose_rep = pose_rep
self.glob = glob
self.glob_rot = glob_rot
self.latent_dim = latent_dim
self.activation = nn.GELU()
self.input_dim = (((self.njoints * self.nfeats) * self.num_frames) + self.num_classes)
self.fully_connected = nn.Sequential(nn.Linear(self.input_dim, 512), nn.GELU(), nn.Linear(512, 256), nn.GELU())
if (self.modeltype == 'cvae'):
self.mu = nn.Linear(256, self.latent_dim)
self.var = nn.Linear(256, self.latent_dim)
else:
self.final = nn.Linear(256, self.latent_dim)
def forward(self, batch):
(x, y) = (batch['x'], batch['y'])
(bs, njoints, feats, nframes) = x.size()
if (((njoints * feats) * nframes) != ((self.njoints * self.nfeats) * self.num_frames)):
raise ValueError('This model is not adapted with this input')
if (len(y.shape) == 1):
y = F.one_hot(y, self.num_classes)
y = y.to(dtype=x.dtype)
x = x.reshape(bs, ((njoints * feats) * nframes))
x = torch.cat((x, y), 1)
x = self.fully_connected(x)
if (self.modeltype == 'cvae'):
return {'mu': self.mu(x), 'logvar': self.var(x)}
else:
return {'z': self.final(x)}
|
class Decoder_FC(nn.Module):
def __init__(self, modeltype, njoints, nfeats, num_frames, num_classes, translation, pose_rep, glob, glob_rot, latent_dim=256, **kargs):
super().__init__()
self.modeltype = modeltype
self.njoints = njoints
self.nfeats = nfeats
self.num_frames = num_frames
self.num_classes = num_classes
self.translation = translation
self.pose_rep = pose_rep
self.glob = glob
self.glob_rot = glob_rot
self.latent_dim = latent_dim
self.input_dim = (self.latent_dim + self.num_classes)
self.output_dim = ((self.njoints * self.nfeats) * self.num_frames)
self.fully_connected = nn.Sequential(nn.Linear(self.input_dim, 256), nn.GELU(), nn.Linear(256, 512), nn.GELU(), nn.Linear(512, self.output_dim), nn.GELU())
def forward(self, batch):
(z, y) = (batch['z'], batch['y'])
if (len(y.shape) == 1):
y = F.one_hot(y, self.num_classes)
y = y.to(dtype=z.dtype)
z = torch.cat((z, y), dim=1)
z = self.fully_connected(z)
(bs, _) = z.size()
z = z.reshape(bs, self.njoints, self.nfeats, self.num_frames)
batch['output'] = z
return batch
|
class GATLayer(nn.Module):
def __init__(self, in_features=768, out_features=768, dropout=0.1, alpha=0.2, concat=True):
super(GATLayer, self).__init__()
self.dropout = dropout
self.in_features = in_features
self.out_features = out_features
self.alpha = alpha
self.concat = concat
self.W = nn.Parameter(torch.empty(size=(in_features, out_features)))
self.leakyrelu = nn.LeakyReLU(self.alpha)
self.a = nn.Parameter(torch.empty(size=((2 * out_features), 1)))
self.ARG0 = nn.Parameter(torch.empty(size=((2 * out_features), 1)))
self.ARG1 = nn.Parameter(torch.empty(size=((2 * out_features), 1)))
self.ARG2 = nn.Parameter(torch.empty(size=((2 * out_features), 1)))
self.ARG3 = nn.Parameter(torch.empty(size=((2 * out_features), 1)))
self.ARG4 = nn.Parameter(torch.empty(size=((2 * out_features), 1)))
self.ARGM_LOC = nn.Parameter(torch.empty(size=((2 * out_features), 1)))
self.ARGM_MNR = nn.Parameter(torch.empty(size=((2 * out_features), 1)))
self.ARGM_TMP = nn.Parameter(torch.empty(size=((2 * out_features), 1)))
self.ARGM_DIR = nn.Parameter(torch.empty(size=((2 * out_features), 1)))
self.ARGM_ADV = nn.Parameter(torch.empty(size=((2 * out_features), 1)))
self.MA = nn.Parameter(torch.empty(size=((2 * out_features), 1)))
self.OTHERS = nn.Parameter(torch.empty(size=((2 * out_features), 1)))
nn.init.xavier_uniform_(self.W.data, gain=1.414)
nn.init.xavier_uniform_(self.a, gain=1.414)
nn.init.xavier_uniform_(self.ARG0.data, gain=1.414)
nn.init.xavier_uniform_(self.ARG1.data, gain=1.414)
nn.init.xavier_uniform_(self.ARG2.data, gain=1.414)
nn.init.xavier_uniform_(self.ARG3.data, gain=1.414)
nn.init.xavier_uniform_(self.ARG4.data, gain=1.414)
nn.init.xavier_uniform_(self.ARGM_LOC.data, gain=1.414)
nn.init.xavier_uniform_(self.ARGM_MNR.data, gain=1.414)
nn.init.xavier_uniform_(self.ARGM_TMP.data, gain=1.414)
nn.init.xavier_uniform_(self.ARGM_DIR.data, gain=1.414)
nn.init.xavier_uniform_(self.ARGM_ADV.data, gain=1.414)
nn.init.xavier_uniform_(self.MA.data, gain=1.414)
nn.init.xavier_uniform_(self.OTHERS.data, gain=1.414)
def forward(self, h0, h1, multi_adj, adj):
Wh0 = torch.einsum('bnd,de->bne', [h0, self.W])
Wh1 = torch.einsum('bnd,de->bne', [h1, self.W])
a_input = self._prepare_attentional_mechanism_input(Wh0, Wh1)
e = self.leakyrelu(torch.matmul(a_input, self.a).squeeze(3))
e_ARG0 = self.leakyrelu(torch.matmul(a_input, self.ARG0).squeeze(3))
e_ARG1 = self.leakyrelu(torch.matmul(a_input, self.ARG1).squeeze(3))
e_ARG2 = self.leakyrelu(torch.matmul(a_input, self.ARG2).squeeze(3))
e_ARG3 = self.leakyrelu(torch.matmul(a_input, self.ARG3).squeeze(3))
e_ARG4 = self.leakyrelu(torch.matmul(a_input, self.ARG4).squeeze(3))
e_ARGM_LOC = self.leakyrelu(torch.matmul(a_input, self.ARGM_LOC).squeeze(3))
e_ARGM_MNR = self.leakyrelu(torch.matmul(a_input, self.ARGM_MNR).squeeze(3))
e_ARGM_TMP = self.leakyrelu(torch.matmul(a_input, self.ARGM_TMP).squeeze(3))
e_ARGM_DIR = self.leakyrelu(torch.matmul(a_input, self.ARGM_DIR).squeeze(3))
e_ARGM_ADV = self.leakyrelu(torch.matmul(a_input, self.ARGM_ADV).squeeze(3))
e_MA = self.leakyrelu(torch.matmul(a_input, self.MA).squeeze(3))
e_OTHERS = self.leakyrelu(torch.matmul(a_input, self.OTHERS).squeeze(3))
zero_vec = ((- 9000000000000000.0) * torch.ones_like(e))
attention = torch.where((adj > 0), e, zero_vec)
zero_vec = torch.zeros_like(e_ARG0)
attention_ARG0 = torch.where((multi_adj['ARG0'] > 0), e_ARG0, zero_vec)
attention_ARG1 = torch.where((multi_adj['ARG1'] > 0), e_ARG1, zero_vec)
attention_ARG2 = torch.where((multi_adj['ARG2'] > 0), e_ARG2, zero_vec)
attention_ARG3 = torch.where((multi_adj['ARG3'] > 0), e_ARG3, zero_vec)
attention_ARG4 = torch.where((multi_adj['ARG4'] > 0), e_ARG4, zero_vec)
attention_ARGM_LOC = torch.where((multi_adj['ARGM-LOC'] > 0), e_ARGM_LOC, zero_vec)
attention_ARGM_MNR = torch.where((multi_adj['ARGM-MNR'] > 0), e_ARGM_MNR, zero_vec)
attention_ARGM_TMP = torch.where((multi_adj['ARGM-TMP'] > 0), e_ARGM_TMP, zero_vec)
attention_ARGM_DIR = torch.where((multi_adj['ARGM-DIR'] > 0), e_ARGM_DIR, zero_vec)
attention_ARGM_ADV = torch.where((multi_adj['ARGM-ADV'] > 0), e_ARGM_ADV, zero_vec)
attention_OTHERS = torch.where((multi_adj['OTHERS'] > 0), e_OTHERS, zero_vec)
attention_MA = torch.where((multi_adj['MA'] > 0), e_MA, zero_vec)
attention = F.softmax((attention + (0.01 * (((((((((((attention_ARG0 + attention_ARG1) + attention_ARG2) + attention_ARG3) + attention_ARG4) + attention_ARGM_LOC) + attention_ARGM_MNR) + attention_ARGM_TMP) + attention_ARGM_DIR) + attention_ARGM_ADV) + attention_OTHERS) + attention_MA))), dim=1)
attention = F.dropout(attention, self.dropout, training=self.training)
h_prime = torch.matmul(attention, Wh1)
if self.concat:
return F.elu(h_prime)
else:
return h_prime
def _prepare_attentional_mechanism_input(self, Wh0, Wh1):
(N0, N1) = (Wh0.size()[1], Wh1.size()[1])
Wh0_repeated_in_chunks = Wh0.repeat_interleave(N1, dim=1)
Wh1_repeated_alternating = Wh1.repeat(1, N0, 1)
all_combinations_matrix = torch.cat([Wh0_repeated_in_chunks, Wh1_repeated_alternating], dim=(- 1))
return all_combinations_matrix.view((- 1), N0, N1, (2 * self.out_features))
|
class MotionDiscriminator(nn.Module):
def __init__(self, input_size, hidden_size, hidden_layer, output_size=12, use_noise=None):
super().__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.hidden_layer = hidden_layer
self.use_noise = use_noise
self.recurrent = nn.GRU(input_size, hidden_size, hidden_layer)
self.linear1 = nn.Linear(hidden_size, 30)
self.linear2 = nn.Linear(30, output_size)
def forward(self, motion_sequence, lengths=None, hidden_unit=None):
(bs, njoints, nfeats, num_frames) = motion_sequence.shape
motion_sequence = motion_sequence.reshape(bs, (njoints * nfeats), num_frames)
motion_sequence = motion_sequence.permute(2, 0, 1)
if (hidden_unit is None):
hidden_unit = self.initHidden(motion_sequence.size(1), self.hidden_layer).to(motion_sequence.device)
(gru_o, _) = self.recurrent(motion_sequence.float(), hidden_unit)
out = gru_o[tuple(torch.stack(((lengths - 1), torch.arange(bs, device=motion_sequence.device))))]
lin1 = self.linear1(out)
lin1 = torch.tanh(lin1)
lin2 = self.linear2(lin1)
return lin2
def initHidden(self, num_samples, layer):
return torch.randn(layer, num_samples, self.hidden_size, requires_grad=False)
|
class MotionDiscriminatorForFID(MotionDiscriminator):
def forward(self, motion_sequence, lengths=None, hidden_unit=None):
(bs, njoints, nfeats, num_frames) = motion_sequence.shape
motion_sequence = motion_sequence.reshape(bs, (njoints * nfeats), num_frames)
motion_sequence = motion_sequence.permute(2, 0, 1)
if (hidden_unit is None):
hidden_unit = self.initHidden(motion_sequence.size(1), self.hidden_layer).to(motion_sequence.device)
(gru_o, _) = self.recurrent(motion_sequence.float(), hidden_unit)
out = gru_o[tuple(torch.stack(((lengths - 1), torch.arange(bs, device=motion_sequence.device))))]
lin1 = self.linear1(out)
lin1 = torch.tanh(lin1)
return lin1
|
class MovementConvEncoder(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(MovementConvEncoder, self).__init__()
self.main = nn.Sequential(nn.Conv1d(input_size, hidden_size, 4, 2, 1), nn.Dropout(0.2, inplace=True), nn.LeakyReLU(0.2, inplace=True), nn.Conv1d(hidden_size, output_size, 4, 2, 1), nn.Dropout(0.2, inplace=True), nn.LeakyReLU(0.2, inplace=True))
self.out_net = nn.Linear(output_size, output_size)
def forward(self, inputs):
inputs = inputs.permute(0, 2, 1)
outputs = self.main(inputs).permute(0, 2, 1)
return self.out_net(outputs)
|
class MotionEncoderBiGRUCo(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(MotionEncoderBiGRUCo, self).__init__()
self.input_emb = nn.Linear(input_size, hidden_size)
self.gru = nn.GRU(hidden_size, hidden_size, batch_first=True, bidirectional=True)
self.output_net = nn.Sequential(nn.Linear((hidden_size * 2), hidden_size), nn.LayerNorm(hidden_size), nn.LeakyReLU(0.2, inplace=True), nn.Linear(hidden_size, output_size))
self.hidden_size = hidden_size
self.hidden = nn.Parameter(torch.randn((2, 1, self.hidden_size), requires_grad=True))
def forward(self, inputs, m_lens):
num_samples = inputs.shape[0]
input_embs = self.input_emb(inputs)
hidden = self.hidden.repeat(1, num_samples, 1)
cap_lens = m_lens.data.tolist()
emb = pack_padded_sequence(input_embs, cap_lens, batch_first=True)
(gru_seq, gru_last) = self.gru(emb, hidden)
gru_last = torch.cat([gru_last[0], gru_last[1]], dim=(- 1))
return self.output_net(gru_last)
|
class TextEncoderBiGRUCo(nn.Module):
def __init__(self, word_size, pos_size, hidden_size, output_size):
super(TextEncoderBiGRUCo, self).__init__()
self.pos_emb = nn.Linear(pos_size, word_size)
self.input_emb = nn.Linear(word_size, hidden_size)
self.gru = nn.GRU(hidden_size, hidden_size, batch_first=True, bidirectional=True)
self.output_net = nn.Sequential(nn.Linear((hidden_size * 2), hidden_size), nn.LayerNorm(hidden_size), nn.LeakyReLU(0.2, inplace=True), nn.Linear(hidden_size, output_size))
self.hidden_size = hidden_size
self.hidden = nn.Parameter(torch.randn((2, 1, self.hidden_size), requires_grad=True))
def forward(self, word_embs, pos_onehot, cap_lens):
num_samples = word_embs.shape[0]
pos_embs = self.pos_emb(pos_onehot)
inputs = (word_embs + pos_embs)
input_embs = self.input_emb(inputs)
hidden = self.hidden.repeat(1, num_samples, 1)
cap_lens = cap_lens.data.tolist()
emb = pack_padded_sequence(input_embs, cap_lens, batch_first=True)
(gru_seq, gru_last) = self.gru(emb, hidden)
gru_last = torch.cat([gru_last[0], gru_last[1]], dim=(- 1))
return self.output_net(gru_last)
|
class STGCN(nn.Module):
'Spatial temporal graph convolutional networks.\n Args:\n in_channels (int): Number of channels in the input data\n num_class (int): Number of classes for the classification task\n graph_args (dict): The arguments for building the graph\n edge_importance_weighting (bool): If ``True``, adds a learnable\n importance weighting to the edges of the graph\n **kwargs (optional): Other parameters for graph convolution units\n Shape:\n - Input: :math:`(N, in_channels, T_{in}, V_{in}, M_{in})`\n - Output: :math:`(N, num_class)` where\n :math:`N` is a batch size,\n :math:`T_{in}` is a length of input sequence,\n :math:`V_{in}` is the number of graph nodes,\n :math:`M_{in}` is the number of instance in a frame.\n '
def __init__(self, in_channels, num_class, kintree_path, graph_args, edge_importance_weighting, **kwargs):
super().__init__()
self.num_class = num_class
self.losses = ['accuracy', 'cross_entropy', 'mixed']
self.criterion = torch.nn.CrossEntropyLoss(reduction='mean')
self.graph = Graph(kintree_path=kintree_path, **graph_args)
A = torch.tensor(self.graph.A, dtype=torch.float32, requires_grad=False)
self.register_buffer('A', A)
spatial_kernel_size = A.size(0)
temporal_kernel_size = 9
kernel_size = (temporal_kernel_size, spatial_kernel_size)
self.data_bn = nn.BatchNorm1d((in_channels * A.size(1)))
kwargs0 = {k: v for (k, v) in kwargs.items() if (k != 'dropout')}
self.st_gcn_networks = nn.ModuleList((st_gcn(in_channels, 64, kernel_size, 1, residual=False, **kwargs0), st_gcn(64, 64, kernel_size, 1, **kwargs), st_gcn(64, 64, kernel_size, 1, **kwargs), st_gcn(64, 64, kernel_size, 1, **kwargs), st_gcn(64, 128, kernel_size, 2, **kwargs), st_gcn(128, 128, kernel_size, 1, **kwargs), st_gcn(128, 128, kernel_size, 1, **kwargs), st_gcn(128, 256, kernel_size, 2, **kwargs), st_gcn(256, 256, kernel_size, 1, **kwargs), st_gcn(256, 256, kernel_size, 1, **kwargs)))
if edge_importance_weighting:
self.edge_importance = nn.ParameterList([nn.Parameter(torch.ones(self.A.size())) for i in self.st_gcn_networks])
else:
self.edge_importance = ([1] * len(self.st_gcn_networks))
self.fcn = nn.Conv2d(256, num_class, kernel_size=1)
def forward(self, motion):
batch = {'output': motion}
x = batch['output'].permute(0, 2, 3, 1).unsqueeze(4).contiguous()
(N, C, T, V, M) = x.size()
x = x.permute(0, 4, 3, 1, 2).contiguous()
x = x.view((N * M), (V * C), T)
x = self.data_bn(x)
x = x.view(N, M, V, C, T)
x = x.permute(0, 1, 3, 4, 2).contiguous()
x = x.view((N * M), C, T, V)
for (gcn, importance) in zip(self.st_gcn_networks, self.edge_importance):
(x, _) = gcn(x, (self.A * importance))
x = F.avg_pool2d(x, x.size()[2:])
x = x.view(N, M, (- 1), 1, 1).mean(dim=1)
batch['features'] = x.squeeze()
x = self.fcn(x)
x = x.view(x.size(0), (- 1))
batch['yhat'] = x
return batch
def compute_accuracy(self, batch):
confusion = torch.zeros(self.num_class, self.num_class, dtype=int)
yhat = batch['yhat'].max(dim=1).indices
ygt = batch['y']
for (label, pred) in zip(ygt, yhat):
confusion[label][pred] += 1
accuracy = (torch.trace(confusion) / torch.sum(confusion))
return accuracy
def compute_loss(self, batch):
cross_entropy = self.criterion(batch['yhat'], batch['y'])
mixed_loss = cross_entropy
acc = self.compute_accuracy(batch)
losses = {'cross_entropy': cross_entropy.item(), 'mixed': mixed_loss.item(), 'accuracy': acc.item()}
return (mixed_loss, losses)
|
class st_gcn(nn.Module):
'Applies a spatial temporal graph convolution over an input graph sequence.\n Args:\n in_channels (int): Number of channels in the input sequence data\n out_channels (int): Number of channels produced by the convolution\n kernel_size (tuple): Size of the temporal convolving kernel and graph convolving kernel\n stride (int, optional): Stride of the temporal convolution. Default: 1\n dropout (int, optional): Dropout rate of the final output. Default: 0\n residual (bool, optional): If ``True``, applies a residual mechanism. Default: ``True``\n Shape:\n - Input[0]: Input graph sequence in :math:`(N, in_channels, T_{in}, V)` format\n - Input[1]: Input graph adjacency matrix in :math:`(K, V, V)` format\n - Output[0]: Outpu graph sequence in :math:`(N, out_channels, T_{out}, V)` format\n - Output[1]: Graph adjacency matrix for output data in :math:`(K, V, V)` format\n where\n :math:`N` is a batch size,\n :math:`K` is the spatial kernel size, as :math:`K == kernel_size[1]`,\n :math:`T_{in}/T_{out}` is a length of input/output sequence,\n :math:`V` is the number of graph nodes.\n '
def __init__(self, in_channels, out_channels, kernel_size, stride=1, dropout=0, residual=True):
super().__init__()
assert (len(kernel_size) == 2)
assert ((kernel_size[0] % 2) == 1)
padding = (((kernel_size[0] - 1) // 2), 0)
self.gcn = ConvTemporalGraphical(in_channels, out_channels, kernel_size[1])
self.tcn = nn.Sequential(nn.BatchNorm2d(out_channels), nn.ReLU(inplace=True), nn.Conv2d(out_channels, out_channels, (kernel_size[0], 1), (stride, 1), padding), nn.BatchNorm2d(out_channels), nn.Dropout(dropout, inplace=True))
if (not residual):
self.residual = (lambda x: 0)
elif ((in_channels == out_channels) and (stride == 1)):
self.residual = (lambda x: x)
else:
self.residual = nn.Sequential(nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=(stride, 1)), nn.BatchNorm2d(out_channels))
self.relu = nn.ReLU(inplace=True)
def forward(self, x, A):
res = self.residual(x)
(x, A) = self.gcn(x, A)
x = (self.tcn(x) + res)
return (self.relu(x), A)
|
class Graph():
" The Graph to model the skeletons extracted by the openpose\n Args:\n strategy (string): must be one of the follow candidates\n - uniform: Uniform Labeling\n - distance: Distance Partitioning\n - spatial: Spatial Configuration\n For more information, please refer to the section 'Partition Strategies'\n in our paper (https://arxiv.org/abs/1801.07455).\n layout (string): must be one of the follow candidates\n - openpose: Is consists of 18 joints. For more information, please\n refer to https://github.com/CMU-Perceptual-Computing-Lab/openpose#output\n - ntu-rgb+d: Is consists of 25 joints. For more information, please\n refer to https://github.com/shahroudy/NTURGB-D\n - smpl: Consists of 24/23 joints with without global rotation.\n max_hop (int): the maximal distance between two connected nodes\n dilation (int): controls the spacing between the kernel points\n "
def __init__(self, kintree_path, layout='openpose', strategy='uniform', max_hop=1, dilation=1):
self.max_hop = max_hop
self.dilation = dilation
self.kintree_path = kintree_path
self.get_edge(layout)
self.hop_dis = get_hop_distance(self.num_node, self.edge, max_hop=max_hop)
self.get_adjacency(strategy)
def __str__(self):
return self.A
def get_edge(self, layout):
if (layout == 'openpose'):
self.num_node = 18
self_link = [(i, i) for i in range(self.num_node)]
neighbor_link = [(4, 3), (3, 2), (7, 6), (6, 5), (13, 12), (12, 11), (10, 9), (9, 8), (11, 5), (8, 2), (5, 1), (2, 1), (0, 1), (15, 0), (14, 0), (17, 15), (16, 14)]
self.edge = (self_link + neighbor_link)
self.center = 1
elif (layout == 'smpl'):
self.num_node = 24
self_link = [(i, i) for i in range(self.num_node)]
kt = pkl.load(open(self.kintree_path, 'rb'))
neighbor_link = [(k, kt[1][(i + 1)]) for (i, k) in enumerate(kt[0][1:])]
self.edge = (self_link + neighbor_link)
self.center = 0
elif (layout == 'smpl_noglobal'):
self.num_node = 23
self_link = [(i, i) for i in range(self.num_node)]
kt = pkl.load(open(self.kintree_path, 'rb'))
neighbor_link = [(k, kt[1][(i + 1)]) for (i, k) in enumerate(kt[0][1:])]
neighbor_1base = [n for n in neighbor_link if ((n[0] != 0) and (n[1] != 0))]
neighbor_link = [((i - 1), (j - 1)) for (i, j) in neighbor_1base]
self.edge = (self_link + neighbor_link)
self.center = 0
elif (layout == 'ntu-rgb+d'):
self.num_node = 25
self_link = [(i, i) for i in range(self.num_node)]
neighbor_1base = [(1, 2), (2, 21), (3, 21), (4, 3), (5, 21), (6, 5), (7, 6), (8, 7), (9, 21), (10, 9), (11, 10), (12, 11), (13, 1), (14, 13), (15, 14), (16, 15), (17, 1), (18, 17), (19, 18), (20, 19), (22, 23), (23, 8), (24, 25), (25, 12)]
neighbor_link = [((i - 1), (j - 1)) for (i, j) in neighbor_1base]
self.edge = (self_link + neighbor_link)
self.center = (21 - 1)
elif (layout == 'ntu_edge'):
self.num_node = 24
self_link = [(i, i) for i in range(self.num_node)]
neighbor_1base = [(1, 2), (3, 2), (4, 3), (5, 2), (6, 5), (7, 6), (8, 7), (9, 2), (10, 9), (11, 10), (12, 11), (13, 1), (14, 13), (15, 14), (16, 15), (17, 1), (18, 17), (19, 18), (20, 19), (21, 22), (22, 8), (23, 24), (24, 12)]
neighbor_link = [((i - 1), (j - 1)) for (i, j) in neighbor_1base]
self.edge = (self_link + neighbor_link)
self.center = 2
else:
raise NotImplementedError('This Layout is not supported')
def get_adjacency(self, strategy):
valid_hop = range(0, (self.max_hop + 1), self.dilation)
adjacency = np.zeros((self.num_node, self.num_node))
for hop in valid_hop:
adjacency[(self.hop_dis == hop)] = 1
normalize_adjacency = normalize_digraph(adjacency)
if (strategy == 'uniform'):
A = np.zeros((1, self.num_node, self.num_node))
A[0] = normalize_adjacency
self.A = A
elif (strategy == 'distance'):
A = np.zeros((len(valid_hop), self.num_node, self.num_node))
for (i, hop) in enumerate(valid_hop):
A[i][(self.hop_dis == hop)] = normalize_adjacency[(self.hop_dis == hop)]
self.A = A
elif (strategy == 'spatial'):
A = []
for hop in valid_hop:
a_root = np.zeros((self.num_node, self.num_node))
a_close = np.zeros((self.num_node, self.num_node))
a_further = np.zeros((self.num_node, self.num_node))
for i in range(self.num_node):
for j in range(self.num_node):
if (self.hop_dis[(j, i)] == hop):
if (self.hop_dis[(j, self.center)] == self.hop_dis[(i, self.center)]):
a_root[(j, i)] = normalize_adjacency[(j, i)]
elif (self.hop_dis[(j, self.center)] > self.hop_dis[(i, self.center)]):
a_close[(j, i)] = normalize_adjacency[(j, i)]
else:
a_further[(j, i)] = normalize_adjacency[(j, i)]
if (hop == 0):
A.append(a_root)
else:
A.append((a_root + a_close))
A.append(a_further)
A = np.stack(A)
self.A = A
else:
raise NotImplementedError('This Strategy is not supported')
|
class ConvTemporalGraphical(nn.Module):
'The basic module for applying a graph convolution.\n Args:\n in_channels (int): Number of channels in the input sequence data\n out_channels (int): Number of channels produced by the convolution\n kernel_size (int): Size of the graph convolving kernel\n t_kernel_size (int): Size of the temporal convolving kernel\n t_stride (int, optional): Stride of the temporal convolution. Default: 1\n t_padding (int, optional): Temporal zero-padding added to both sides of\n the input. Default: 0\n t_dilation (int, optional): Spacing between temporal kernel elements.\n Default: 1\n bias (bool, optional): If ``True``, adds a learnable bias to the output.\n Default: ``True``\n Shape:\n - Input[0]: Input graph sequence in :math:`(N, in_channels, T_{in}, V)` format\n - Input[1]: Input graph adjacency matrix in :math:`(K, V, V)` format\n - Output[0]: Outpu graph sequence in :math:`(N, out_channels, T_{out}, V)` format\n - Output[1]: Graph adjacency matrix for output data in :math:`(K, V, V)` format\n where\n :math:`N` is a batch size,\n :math:`K` is the spatial kernel size, as :math:`K == kernel_size[1]`,\n :math:`T_{in}/T_{out}` is a length of input/output sequence,\n :math:`V` is the number of graph nodes.\n '
def __init__(self, in_channels, out_channels, kernel_size, t_kernel_size=1, t_stride=1, t_padding=0, t_dilation=1, bias=True):
super().__init__()
self.kernel_size = kernel_size
self.conv = nn.Conv2d(in_channels, (out_channels * kernel_size), kernel_size=(t_kernel_size, 1), padding=(t_padding, 0), stride=(t_stride, 1), dilation=(t_dilation, 1), bias=bias)
def forward(self, x, A):
assert (A.size(0) == self.kernel_size)
x = self.conv(x)
(n, kc, t, v) = x.size()
x = x.view(n, self.kernel_size, (kc // self.kernel_size), t, v)
x = torch.einsum('nkctv,kvw->nctw', (x, A))
return (x.contiguous(), A)
|
def get_hop_distance(num_node, edge, max_hop=1):
A = np.zeros((num_node, num_node))
for (i, j) in edge:
A[(j, i)] = 1
A[(i, j)] = 1
hop_dis = (np.zeros((num_node, num_node)) + np.inf)
transfer_mat = [np.linalg.matrix_power(A, d) for d in range((max_hop + 1))]
arrive_mat = (np.stack(transfer_mat) > 0)
for d in range(max_hop, (- 1), (- 1)):
hop_dis[arrive_mat[d]] = d
return hop_dis
|
def normalize_digraph(A):
Dl = np.sum(A, 0)
num_node = A.shape[0]
Dn = np.zeros((num_node, num_node))
for i in range(num_node):
if (Dl[i] > 0):
Dn[(i, i)] = (Dl[i] ** (- 1))
AD = np.dot(A, Dn)
return AD
|
def normalize_undigraph(A):
Dl = np.sum(A, 0)
num_node = A.shape[0]
Dn = np.zeros((num_node, num_node))
for i in range(num_node):
if (Dl[i] > 0):
Dn[(i, i)] = (Dl[i] ** (- 0.5))
DAD = np.dot(np.dot(Dn, A), Dn)
return DAD
|
class VPosert(nn.Module):
def __init__(self, cfg, **kwargs) -> None:
super(VPosert, self).__init__()
num_neurons = 512
self.latentD = 256
n_features = (196 * 263)
self.encoder_net = nn.Sequential(BatchFlatten(), nn.BatchNorm1d(n_features), nn.Linear(n_features, num_neurons), nn.LeakyReLU(), nn.BatchNorm1d(num_neurons), nn.Dropout(0.1), nn.Linear(num_neurons, num_neurons), nn.Linear(num_neurons, num_neurons), NormalDistDecoder(num_neurons, self.latentD))
self.decoder_net = nn.Sequential(nn.Linear(self.latentD, num_neurons), nn.LeakyReLU(), nn.Dropout(0.1), nn.Linear(num_neurons, num_neurons), nn.LeakyReLU(), nn.Linear(num_neurons, n_features), ContinousRotReprDecoder())
def forward(self, features: Tensor, lengths: Optional[List[int]]=None):
q_z = self.encode(features)
feats_rst = self.decode(q_z)
return (feats_rst, q_z)
def encode(self, pose_body, lengths: Optional[List[int]]=None):
"\n :param Pin: Nx(numjoints*3)\n :param rep_type: 'matrot'/'aa' for matrix rotations or axis-angle\n :return:\n "
q_z = self.encoder_net(pose_body)
q_z_sample = q_z.rsample()
return (q_z_sample.unsqueeze(0), q_z)
def decode(self, Zin, lengths: Optional[List[int]]=None):
bs = Zin.shape[0]
Zin = Zin[0]
prec = self.decoder_net(Zin)
return prec
|
class BatchFlatten(nn.Module):
def __init__(self):
super(BatchFlatten, self).__init__()
self._name = 'batch_flatten'
def forward(self, x):
return x.view(x.shape[0], (- 1))
|
class ContinousRotReprDecoder(nn.Module):
def __init__(self):
super(ContinousRotReprDecoder, self).__init__()
def forward(self, module_input):
reshaped_input = module_input.view((- 1), 196, 263)
return reshaped_input
|
class NormalDistDecoder(nn.Module):
def __init__(self, num_feat_in, latentD):
super(NormalDistDecoder, self).__init__()
self.mu = nn.Linear(num_feat_in, latentD)
self.logvar = nn.Linear(num_feat_in, latentD)
def forward(self, Xout):
return torch.distributions.normal.Normal(self.mu(Xout), F.softplus(self.logvar(Xout)))
|
def get_model(cfg, datamodule, phase='train'):
modeltype = cfg.model.model_type
if (modeltype == 'GraphMotion'):
return get_module(cfg, datamodule)
else:
raise ValueError(f'Invalid model type {modeltype}.')
|
def get_module(cfg, datamodule):
modeltype = cfg.model.model_type
model_module = importlib.import_module(f'.modeltype.{cfg.model.model_type}', package='GraphMotion.models')
Model = model_module.__getattribute__(f'{modeltype}')
return Model(cfg=cfg, datamodule=datamodule)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.