Spaces:
Sleeping
Sleeping
File size: 5,490 Bytes
e6d357a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 | import numpy as np
import torch
from torch.utils.data import DataLoader, Dataset
from typing import Dict, Set
from tqdm import tqdm
def compute_mean_motions(dataset, batch_size=128, if_traj_only=False):
if isinstance(dataset, Dataset):
data_loader = DataLoader(dataset, shuffle=False, batch_size=batch_size, num_workers=1, pin_memory= True, drop_last=False,)
else:
assert isinstance(dataset, DataLoader)
data_loader = dataset
counter = 0
average_3d = 0
CLASS_TO_IDX = data_loader.dataset.class_to_idx
class_average_3d = {k: 0 for k in CLASS_TO_IDX}
class_counter = {k: 0 for k in CLASS_TO_IDX}
for batch_idx, batch in enumerate(data_loader):
data, target, extra = batch
classes = np.array([CLASS_TO_IDX[c] for c in extra["metadata"][data_loader.dataset.metadata_class_idx]])
target = data_loader.dataset.skeleton.transform_to_metric_space(target)
if if_traj_only:
target = target[..., 0:1, :]
target_3d = target
average_3d += (np.linalg.norm(target_3d[..., 1:, :, :] - target_3d[..., :-1, :, :], axis=-1)).mean()
counter += 1
for class_label in CLASS_TO_IDX:
c = CLASS_TO_IDX[class_label]
class_mask = classes == c
target_class_3d = target_3d[class_mask]
class_average_3d[class_label] += (np.linalg.norm(target_class_3d[:, 1:] - target_class_3d[:, :-1], axis=-1)).mean(axis=-1).mean(axis=-1).sum()
class_counter[class_label] += target_class_3d.shape[0]
print(f"AVERAGE={average_3d/counter:.8f}")
total_class_counter = sum(class_counter.values())
list_of_motions_3d = []
frequencies = []
for c in class_average_3d:
print(f"{c}: {class_average_3d[c]/class_counter[c]:.8f}")
list_of_motions_3d.append(float((class_average_3d[c]/class_counter[c])))
frequencies.append(class_counter[c]/total_class_counter)
return class_average_3d, list_of_motions_3d, frequencies
############################################################################################################
# For multimodal GT
def get_multimodal_gt(data_loader, multimodal_threshold, recover_landmarks=True):
def get_mmgt_idxs(seq1: torch.Tensor, seq2: torch.Tensor, multimodal_threshold:float):
seq1 = seq1.reshape(seq1.shape[0], -1)
seq2 = seq2.reshape(seq2.shape[0], -1)
pd = torch.cdist(seq1, seq2, p=2, compute_mode='donot_use_mm_for_euclid_dist') # obtain same exact results to scipy.spatial.distance.squareform(scipy.spatial.distance.pdist(obs)) as in previous works (BeLFusion)
ind = np.nonzero(pd < multimodal_threshold) # (n_similar, 2). The last dimension indexes the pd matrix
return ind
def store_mmgt_idxs(i: int, j: int, batch_size: int, idxs: torch.Tensor, gt_idces_dict: Dict[int, Set[int]]):
# shape of tensor idxs is [Any, 2]
idxs_mapped = idxs.clone()
idxs_mapped[:, 0:1] += i * batch_size
idxs_mapped[:, 1:] += j * batch_size
for k in range(idxs_mapped.shape[0]):
segment1 = idxs_mapped[k][0].item()
segment2 = idxs_mapped[k][1].item()
if segment1 not in gt_idces_dict:
gt_idces_dict[segment1] = set()
if segment2 not in gt_idces_dict:
gt_idces_dict[segment2] = set()
gt_idces_dict[segment1].add(segment2)
gt_idces_dict[segment2].add(segment1)
return gt_idces_dict
batch_size = data_loader.batch_size
gt_idces_dict2 = {}
for b_i, batch_i in enumerate(tqdm(data_loader, total = len(data_loader), desc ="Number of batches processed")):
data, target, extra = batch_i
if recover_landmarks:
data = data_loader.dataset.skeleton.transform_to_metric_space(data)
idx = extra["segment_idx"]
assert (idx == torch.arange(start=b_i*batch_size, end=min((b_i+1)*batch_size, len(data_loader.dataset)))).all(), "The segment idxs are not as expected! Dataloaders does noto deliver segments in order."
# seq_length, n_joints, n_features = target.shape[1:]
# dataset is too big we need to compute the pairwise distance in chunks
for b_j, batch_j in enumerate(tqdm(data_loader, total = len(data_loader) - b_i, leave=False, desc ="subprocess")):
if b_i > b_j :
# we have already computed th mmgt between batch_i and batch_j
continue
data2, target2, extra2 = batch_j
if recover_landmarks:
data2 = data_loader.dataset.skeleton.transform_to_metric_space(data2)
mmgt_idxs = get_mmgt_idxs(data[:, -1], data2[:, -1], multimodal_threshold)
gt_idces_dict2 = store_mmgt_idxs(i=b_i, j=b_j, batch_size=batch_size, idxs=mmgt_idxs, gt_idces_dict=gt_idces_dict2)
assert all([ k in gt_idces_dict2[seg] for k, v in gt_idces_dict2.items() for seg in v ]), "The multimodal GT is not symmetric."
gt_idces_dict2 = {k: {v for v in sorted(gt_idces_dict2[k])} for k in sorted(gt_idces_dict2)}
avg_num_mmgt = sum([len(v) for v in gt_idces_dict2.values()])/len(gt_idces_dict2)
std_num_mmmgt = np.std([len(v) for v in gt_idces_dict2.values()])/len(gt_idces_dict2)
print(f'Average number of similar trajectories: {avg_num_mmgt}. Standard deviation: {std_num_mmmgt}. Total n of mmgt: {sum([len(v) for v in gt_idces_dict2.values()])}')
return gt_idces_dict2 |