Spaces:
Sleeping
Sleeping
Download src/data/loaders/base/math_utils.py from ceccurr/EquiFusion: direct link, hf CLI and curl.
- Browser
- Download file 5.49 kB
-
https://huggingface.co/spaces/ceccurr/EquiFusion/resolve/main/src/data/loaders/base/math_utils.py
- Command line
-
hf download hf://spaces/ceccurr/EquiFusion/src/data/loaders/base/math_utils.py
-
curl -L -o math_utils.py https://huggingface.co/spaces/ceccurr/EquiFusion/resolve/main/src/data/loaders/base/math_utils.py
5.49 kB
| 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 |