vismatch 1.1.1__py3-none-any.whl

vismatch/third_party/EDM/src/utils/metrics.py

@@ -0,0 +1,299 @@
+import torch
+import cv2
+import numpy as np
+from collections import OrderedDict
+from loguru import logger
+from kornia.geometry.epipolar import numeric
+from kornia.geometry.conversions import convert_points_to_homogeneous
+
+
+# --- METRICS ---
+
+
+def relative_pose_error(T_0to1, R, t, ignore_gt_t_thr=0.0):
+    # angle error between 2 vectors
+    t_gt = T_0to1[:3, 3]
+    n = np.linalg.norm(t) * np.linalg.norm(t_gt)
+    t_err = np.rad2deg(np.arccos(np.clip(np.dot(t, t_gt) / n, -1.0, 1.0)))
+    t_err = np.minimum(t_err, 180 - t_err)  # handle E ambiguity
+    if np.linalg.norm(t_gt) < ignore_gt_t_thr:  # pure rotation is challenging
+        t_err = 0
+
+    # angle error between 2 rotation matrices
+    R_gt = T_0to1[:3, :3]
+    cos = (np.trace(np.dot(R.T, R_gt)) - 1) / 2
+    cos = np.clip(cos, -1.0, 1.0)  # handle numercial errors
+    R_err = np.rad2deg(np.abs(np.arccos(cos)))
+
+    return t_err, R_err
+
+
+def symmetric_epipolar_distance(pts0, pts1, E, K0, K1):
+    """Squared symmetric epipolar distance.
+    This can be seen as a biased estimation of the reprojection error.
+    Args:
+        pts0 (torch.Tensor): [N, 2]
+        E (torch.Tensor): [3, 3]
+    """
+    pts0 = (pts0 - K0[[0, 1], [2, 2]][None]) / K0[[0, 1], [0, 1]][None]
+    pts1 = (pts1 - K1[[0, 1], [2, 2]][None]) / K1[[0, 1], [0, 1]][None]
+    pts0 = convert_points_to_homogeneous(pts0)
+    pts1 = convert_points_to_homogeneous(pts1)
+
+    Ep0 = pts0 @ E.T  # [N, 3]
+    p1Ep0 = torch.sum(pts1 * Ep0, -1)  # [N,]
+    Etp1 = pts1 @ E  # [N, 3]
+
+    d = p1Ep0**2 * (
+        1.0 / (Ep0[:, 0] ** 2 + Ep0[:, 1] ** 2)
+        + 1.0 / (Etp1[:, 0] ** 2 + Etp1[:, 1] ** 2)
+    )  # N
+    return d
+
+
+def compute_symmetrical_epipolar_errors(data):
+    """
+    Update:
+        data (dict):{"epi_errs": [M]}
+    """
+    Tx = numeric.cross_product_matrix(data["T_0to1"][:, :3, 3])
+    E_mat = Tx @ data["T_0to1"][:, :3, :3]
+
+    m_bids = data["m_bids"].clone().detach()
+    pts0 = data["mkpts0_f"].clone().detach()
+    pts1 = data["mkpts1_f"].clone().detach()
+
+    epi_errs = []
+    for bs in range(Tx.size(0)):
+        mask = m_bids == bs
+        epi_errs.append(
+            symmetric_epipolar_distance(
+                pts0[mask], pts1[mask], E_mat[bs], data["K0"][bs], data["K1"][bs]
+            )
+        )
+    epi_errs = torch.cat(epi_errs, dim=0)
+
+    data.update({"epi_errs": epi_errs})
+
+
+def estimate_pose(kpts0, kpts1, K0, K1, thresh, conf=0.99999):
+    if len(kpts0) < 5:
+        return None
+    # normalize keypoints
+    kpts0 = (kpts0 - K0[[0, 1], [2, 2]][None]) / K0[[0, 1], [0, 1]][None]
+    kpts1 = (kpts1 - K1[[0, 1], [2, 2]][None]) / K1[[0, 1], [0, 1]][None]
+
+    # normalize ransac threshold
+    ransac_thr = thresh / np.mean([K0[0, 0], K1[1, 1], K0[0, 0], K1[1, 1]])
+
+    # compute pose with cv2
+    E, mask = cv2.findEssentialMat(
+        kpts0, kpts1, np.eye(3), threshold=ransac_thr, prob=conf, method=cv2.RANSAC
+    )
+    if E is None:
+        print("\nE is None while trying to recover pose.\n")
+        return None
+
+    # recover pose from E
+    best_num_inliers = 0
+    ret = None
+    for _E in np.split(E, len(E) / 3):
+        n, R, t, _ = cv2.recoverPose(
+            _E, kpts0, kpts1, np.eye(3), 1e9, mask=mask)
+        if n > best_num_inliers:
+            ret = (R, t[:, 0], mask.ravel() > 0)
+            best_num_inliers = n
+
+    return ret
+
+
+def estimate_lo_pose(kpts0, kpts1, K0, K1, thresh, conf=0.99999):
+    from .warppers import Camera, Pose
+    import poselib
+
+    camera0, camera1 = (
+        Camera.from_calibration_matrix(K0).float(),
+        Camera.from_calibration_matrix(K1).float(),
+    )
+    pts0, pts1 = kpts0, kpts1
+
+    M, info = poselib.estimate_relative_pose(
+        pts0,
+        pts1,
+        camera0.to_cameradict(),
+        camera1.to_cameradict(),
+        {
+            "max_epipolar_error": thresh,
+        },
+    )
+    success = M is not None and (
+        ((M.t != [0.0, 0.0, 0.0]).all()) or (
+            (M.q != [1.0, 0.0, 0.0, 0.0]).all())
+    )
+    if success:
+        M = Pose.from_Rt(torch.tensor(M.R), torch.tensor(M.t))  # .to(pts0)
+        # print(M)
+    else:
+        M = Pose.from_4x4mat(torch.eye(4).numpy())  # .to(pts0)
+        # print(M)
+
+    estimation = {
+        "success": success,
+        "M_0to1": M,
+        "inliers": torch.tensor(info.pop("inliers")),  # .to(pts0),
+        **info,
+    }
+    return estimation
+
+
+def compute_pose_errors(data, config):
+    """
+    Update:
+        data (dict):{
+            "R_errs" List[float]: [N]
+            "t_errs" List[float]: [N]
+            "inliers" List[np.ndarray]: [N]
+        }
+    """
+    pixel_thr = config.TRAINER.RANSAC_PIXEL_THR  # 0.5
+    conf = config.TRAINER.RANSAC_CONF  # 0.99999
+    RANSAC = config.TRAINER.POSE_ESTIMATION_METHOD
+    data.update({"R_errs": [], "t_errs": [], "inliers": []})
+
+    m_bids = data["m_bids"].clone().detach().cpu().numpy()
+    pts0 = data["mkpts0_f"].clone().detach().cpu().numpy()
+    pts1 = data["mkpts1_f"].clone().detach().cpu().numpy()
+    K0 = data["K0"].cpu().numpy()
+    K1 = data["K1"].cpu().numpy()
+    T_0to1 = data["T_0to1"].cpu().numpy()
+
+    for bs in range(K0.shape[0]):
+        mask = m_bids == bs
+        if config.EDM.EVAL_TIMES >= 1:
+            bpts0, bpts1 = pts0[mask], pts1[mask]
+            R_list, T_list, inliers_list = [], [], []
+            # for _ in range(config.EDM.EVAL_TIMES):
+            for _ in range(5):
+                shuffling = np.random.permutation(np.arange(len(bpts0)))
+                if _ >= config.EDM.EVAL_TIMES:
+                    continue
+                bpts0 = bpts0[shuffling]
+                bpts1 = bpts1[shuffling]
+
+                if RANSAC == "RANSAC":
+                    ret = estimate_pose(
+                        bpts0, bpts1, K0[bs], K1[bs], pixel_thr, conf=conf
+                    )
+                    if ret is None:
+                        R_list.append(np.inf)
+                        T_list.append(np.inf)
+                        inliers_list.append(np.array([]).astype(bool))
+                    else:
+                        R, t, inliers = ret
+                        t_err, R_err = relative_pose_error(
+                            T_0to1[bs], R, t, ignore_gt_t_thr=0.0
+                        )
+                        R_list.append(R_err)
+                        T_list.append(t_err)
+                        inliers_list.append(inliers)
+
+                elif RANSAC == "LO-RANSAC":
+                    est = estimate_lo_pose(
+                        bpts0, bpts1, K0[bs], K1[bs], pixel_thr, conf=conf
+                    )
+                    if not est["success"]:
+                        R_list.append(90)
+                        T_list.append(90)
+                        inliers_list.append(np.array([]).astype(bool))
+                    else:
+                        M = est["M_0to1"]
+                        inl = est["inliers"].numpy()
+                        t_error, r_error = relative_pose_error(
+                            T_0to1[bs], M.R, M.t, ignore_gt_t_thr=0.0
+                        )
+                        R_list.append(r_error)
+                        T_list.append(t_error)
+                        inliers_list.append(inl)
+                else:
+                    raise ValueError(f"Unknown RANSAC method: {RANSAC}")
+
+            data["R_errs"].append(R_list)
+            data["t_errs"].append(T_list)
+            data["inliers"].append(inliers_list[0])
+
+
+# --- METRIC AGGREGATION ---
+
+
+def error_auc(errors, thresholds):
+    """
+    Args:
+        errors (list): [N,]
+        thresholds (list)
+    """
+    errors = [0] + sorted(list(errors))
+    recall = list(np.linspace(0, 1, len(errors)))
+
+    aucs = []
+    thresholds = [5, 10, 20]
+    for thr in thresholds:
+        last_index = np.searchsorted(errors, thr)
+        y = recall[:last_index] + [recall[last_index - 1]]
+        x = errors[:last_index] + [thr]
+        aucs.append(np.trapz(y, x) / thr)
+
+    return {f"auc@{t}": auc for t, auc in zip(thresholds, aucs)}
+
+
+def epidist_prec(errors, thresholds, ret_dict=False):
+    precs = []
+    for thr in thresholds:
+        prec_ = []
+        for errs in errors:
+            correct_mask = errs < thr
+            prec_.append(np.mean(correct_mask) if len(correct_mask) > 0 else 0)
+        precs.append(np.mean(prec_) if len(prec_) > 0 else 0)
+    if ret_dict:
+        return {f"prec@{t:.0e}": prec for t, prec in zip(thresholds, precs)}
+    else:
+        return precs
+
+
+def aggregate_metrics(metrics, epi_err_thr=5e-4, config=None):
+    """Aggregate metrics for the whole dataset:
+    (This method should be called once per dataset)
+    1. AUC of the pose error (angular) at the threshold [5, 10, 20]
+    2. Mean matching precision at the threshold 5e-4(ScanNet), 1e-4(MegaDepth)
+    """
+    # filter duplicates
+    unq_ids = OrderedDict((iden, id)
+                          for id, iden in enumerate(metrics["identifiers"]))
+    unq_ids = list(unq_ids.values())
+    logger.info(f"Aggregating metrics over {len(unq_ids)} unique items...")
+
+    # pose auc
+    angular_thresholds = [5, 10, 20]
+
+    if config.EDM.EVAL_TIMES >= 1:
+        pose_errors = (
+            np.max(np.stack([metrics["R_errs"], metrics["t_errs"]]), axis=0)
+            .reshape(-1, config.EDM.EVAL_TIMES)[unq_ids]
+            .reshape(-1)
+        )
+    else:
+        pose_errors = np.max(np.stack([metrics["R_errs"], metrics["t_errs"]]), axis=0)[
+            unq_ids
+        ]
+    # (auc@5, auc@10, auc@20)
+    aucs = error_auc(pose_errors, angular_thresholds)
+
+    # matching precision
+    dist_thresholds = [epi_err_thr]
+    precs = epidist_prec(
+        np.array(metrics["epi_errs"], dtype=object)[
+            unq_ids], dist_thresholds, True
+    )  # (prec@err_thr)
+
+    u_num_mathces = np.array(metrics["num_matches"], dtype=object)[unq_ids]
+    num_matches = {f"num_matches": u_num_mathces.mean()}
+    return {**aucs, **precs, **num_matches}

vismatch/third_party/EDM/src/utils/misc.py

@@ -0,0 +1,113 @@
+import os
+import contextlib
+import joblib
+from typing import Union
+from loguru import _Logger, logger
+from itertools import chain
+
+import torch
+from yacs.config import CfgNode as CN
+from lightning.pytorch.utilities import rank_zero_only
+
+
+def lower_config(yacs_cfg):
+    if not isinstance(yacs_cfg, CN):
+        return yacs_cfg
+    return {k.lower(): lower_config(v) for k, v in yacs_cfg.items()}
+
+
+def upper_config(dict_cfg):
+    if not isinstance(dict_cfg, dict):
+        return dict_cfg
+    return {k.upper(): upper_config(v) for k, v in dict_cfg.items()}
+
+
+def log_on(condition, message, level):
+    if condition:
+        assert level in ["INFO", "DEBUG", "WARNING", "ERROR", "CRITICAL"]
+        logger.log(level, message)
+
+
+def get_rank_zero_only_logger(logger: _Logger):
+    if rank_zero_only.rank == 0:
+        return logger
+    else:
+        for _level in logger._core.levels.keys():
+            level = _level.lower()
+            setattr(logger, level, lambda x: None)
+        logger._log = lambda x: None
+    return logger
+
+
+def setup_gpus(gpus: Union[str, int]) -> int:
+    """A temporary fix for pytorch-lighting 1.3.x"""
+    gpus = str(gpus)
+    gpu_ids = []
+
+    if "," not in gpus:
+        n_gpus = int(gpus)
+        return n_gpus if n_gpus != -1 else torch.cuda.device_count()
+    else:
+        gpu_ids = [i.strip() for i in gpus.split(",") if i != ""]
+
+    # setup environment variables
+    visible_devices = os.getenv("CUDA_VISIBLE_DEVICES")
+    if visible_devices is None:
+        os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+        os.environ["CUDA_VISIBLE_DEVICES"] = ",".join(str(i) for i in gpu_ids)
+        visible_devices = os.getenv("CUDA_VISIBLE_DEVICES")
+        logger.warning(
+            f"[Temporary Fix] manually set CUDA_VISIBLE_DEVICES when specifying gpus to use: {visible_devices}"
+        )
+    else:
+        logger.warning(
+            "[Temporary Fix] CUDA_VISIBLE_DEVICES already set by user or the main process."
+        )
+    return len(gpu_ids)
+
+
+def flattenList(x):
+    return list(chain(*x))
+
+
+@contextlib.contextmanager
+def tqdm_joblib(tqdm_object):
+    """Context manager to patch joblib to report into tqdm progress bar given as argument
+
+    Usage:
+        with tqdm_joblib(tqdm(desc="My calculation", total=10)) as progress_bar:
+            Parallel(n_jobs=16)(delayed(sqrt)(i**2) for i in range(10))
+
+    When iterating over a generator, directly use of tqdm is also a solutin (but monitor the task queuing, instead of finishing)
+        ret_vals = Parallel(n_jobs=args.world_size)(
+                    delayed(lambda x: _compute_cov_score(pid, *x))(param)
+                        for param in tqdm(combinations(image_ids, 2),
+                                          desc=f'Computing cov_score of [{pid}]',
+                                          total=len(image_ids)*(len(image_ids)-1)/2))
+    Src: https://stackoverflow.com/a/58936697
+    """
+
+    class TqdmBatchCompletionCallback(joblib.parallel.BatchCompletionCallBack):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+
+        def __call__(self, *args, **kwargs):
+            tqdm_object.update(n=self.batch_size)
+            return super().__call__(*args, **kwargs)
+
+    old_batch_callback = joblib.parallel.BatchCompletionCallBack
+    joblib.parallel.BatchCompletionCallBack = TqdmBatchCompletionCallback
+    try:
+        yield tqdm_object
+    finally:
+        joblib.parallel.BatchCompletionCallBack = old_batch_callback
+        tqdm_object.close()
+
+
+def detect_NaN(feat_0, feat_1):
+    logger.info(f"NaN detected in feature")
+    logger.info(
+        f"#NaN in feat_0: {torch.isnan(feat_0).int().sum()}, #NaN in feat_1: {torch.isnan(feat_1).int().sum()}"
+    )
+    feat_0[torch.isnan(feat_0)] = 0
+    feat_1[torch.isnan(feat_1)] = 0

vismatch/third_party/EDM/src/utils/plotting.py

@@ -0,0 +1,186 @@
+import bisect
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib
+
+
+def _compute_conf_thresh(data):
+    dataset_name = data["dataset_name"][0].lower()
+    if dataset_name == "scannet":
+        thr = 5e-4
+    elif dataset_name == "megadepth":
+        thr = 1e-4
+    else:
+        raise ValueError(f"Unknown dataset: {dataset_name}")
+    return thr
+
+
+# --- VISUALIZATION --- #
+
+
+def make_matching_figure(
+    img0,
+    img1,
+    mkpts0,
+    mkpts1,
+    color,
+    kpts0=None,
+    kpts1=None,
+    text=[],
+    dpi=75,
+    path=None,
+):
+    # draw image pair
+    assert (
+        mkpts0.shape[0] == mkpts1.shape[0]
+    ), f"mkpts0: {mkpts0.shape[0]} v.s. mkpts1: {mkpts1.shape[0]}"
+    fig, axes = plt.subplots(1, 2, figsize=(10, 6), dpi=dpi)
+    axes[0].imshow(img0, cmap="gray")
+    axes[1].imshow(img1, cmap="gray")
+    for i in range(2):  # clear all frames
+        axes[i].get_yaxis().set_ticks([])
+        axes[i].get_xaxis().set_ticks([])
+        for spine in axes[i].spines.values():
+            spine.set_visible(False)
+    plt.tight_layout(pad=1)
+
+    if kpts0 is not None:
+        assert kpts1 is not None
+        axes[0].scatter(kpts0[:, 0], kpts0[:, 1], c="w", s=2)
+        axes[1].scatter(kpts1[:, 0], kpts1[:, 1], c="w", s=2)
+
+    # draw matches
+    if mkpts0.shape[0] != 0 and mkpts1.shape[0] != 0:
+        fig.canvas.draw()
+        transFigure = fig.transFigure.inverted()
+        fkpts0 = transFigure.transform(axes[0].transData.transform(mkpts0))
+        fkpts1 = transFigure.transform(axes[1].transData.transform(mkpts1))
+        fig.lines = [
+            matplotlib.lines.Line2D(
+                (fkpts0[i, 0], fkpts1[i, 0]),
+                (fkpts0[i, 1], fkpts1[i, 1]),
+                transform=fig.transFigure,
+                c=color[i],
+                linewidth=1,
+            )
+            for i in range(len(mkpts0))
+        ]
+
+        axes[0].scatter(mkpts0[:, 0], mkpts0[:, 1], c=color, s=4)
+        axes[1].scatter(mkpts1[:, 0], mkpts1[:, 1], c=color, s=4)
+
+    # put txts
+    txt_color = "k" if img0[:100, :200].mean() > 200 else "w"
+    fig.text(
+        0.01,
+        0.99,
+        "\n".join(text),
+        transform=fig.axes[0].transAxes,
+        fontsize=15,
+        va="top",
+        ha="left",
+        color=txt_color,
+    )
+
+    # save or return figure
+    if path:
+        plt.savefig(str(path), bbox_inches="tight", pad_inches=0)
+        plt.close()
+    else:
+        return fig
+
+
+def _make_evaluation_figure(data, b_id, alpha="dynamic"):
+    b_mask = data["m_bids"] == b_id
+    conf_thr = _compute_conf_thresh(data)
+
+    img0 = (data["image0"][b_id][0].cpu().numpy()
+            * 255).round().astype(np.int32)
+    img1 = (data["image1"][b_id][0].cpu().numpy()
+            * 255).round().astype(np.int32)
+    kpts0 = data["mkpts0_f"][b_mask].clone().detach().cpu().numpy()
+    kpts1 = data["mkpts1_f"][b_mask].clone().detach().cpu().numpy()
+
+    # for megadepth, we visualize matches on the resized image
+    if "scale0" in data:
+        kpts0 = kpts0 / data["scale0"][b_id].cpu().numpy()[[1, 0]]
+        kpts1 = kpts1 / data["scale1"][b_id].cpu().numpy()[[1, 0]]
+
+    epi_errs = data["epi_errs"][b_mask].cpu().numpy()
+    correct_mask = epi_errs < conf_thr
+    precision = np.mean(correct_mask) if len(correct_mask) > 0 else 0
+    n_correct = np.sum(correct_mask)
+    n_gt_matches = int(data["conf_matrix_gt"][b_id].sum().cpu())
+    recall = 0 if n_gt_matches == 0 else n_correct / (n_gt_matches)
+    # recall might be larger than 1, since the calculation of conf_matrix_gt
+    # uses groundtruth depths and camera poses, but epipolar distance is used here.
+
+    # matching info
+    if alpha == "dynamic":
+        alpha = dynamic_alpha(len(correct_mask))
+    color = error_colormap(epi_errs, conf_thr, alpha=alpha)
+
+    text = [
+        f"#Matches {len(kpts0)}",
+        f"Precision({conf_thr:.2e}) ({100 * precision:.1f}%): {n_correct}/{len(kpts0)}",
+        f"Recall({conf_thr:.2e}) ({100 * recall:.1f}%): {n_correct}/{n_gt_matches}",
+    ]
+
+    # make the figure
+    figure = make_matching_figure(img0, img1, kpts0, kpts1, color, text=text)
+    return figure
+
+
+def _make_confidence_figure(data, b_id):
+    # TODO: Implement confidence figure
+    raise NotImplementedError()
+
+
+def make_matching_figures(data, config, mode="evaluation"):
+    """Make matching figures for a batch.
+
+    Args:
+        data (Dict): a batch updated by PL_LoFTR.
+        config (Dict): matcher config
+    Returns:
+        figures (Dict[str, List[plt.figure]]
+    """
+    assert mode in ["evaluation", "confidence", "gt"]  # 'confidence'
+    figures = {mode: []}
+    for b_id in range(data["image0"].size(0)):
+        if mode == "evaluation":
+            fig = _make_evaluation_figure(
+                data, b_id, alpha=config.TRAINER.PLOT_MATCHES_ALPHA
+            )
+        elif mode == "confidence":
+            fig = _make_confidence_figure(data, b_id)
+        else:
+            raise ValueError(f"Unknown plot mode: {mode}")
+        figures[mode].append(fig)
+    return figures
+
+
+def dynamic_alpha(
+    n_matches, milestones=[0, 300, 1000, 2000], alphas=[1.0, 0.8, 0.4, 0.2]
+):
+    if n_matches == 0:
+        return 1.0
+    ranges = list(zip(alphas, alphas[1:] + [None]))
+    loc = bisect.bisect_right(milestones, n_matches) - 1
+    _range = ranges[loc]
+    if _range[1] is None:
+        return _range[0]
+    return _range[1] + (milestones[loc + 1] - n_matches) / (
+        milestones[loc + 1] - milestones[loc]
+    ) * (_range[0] - _range[1])
+
+
+def error_colormap(err, thr, alpha=1.0):
+    assert alpha <= 1.0 and alpha > 0, f"Invaid alpha value: {alpha}"
+    x = 1 - np.clip(err / (thr * 2), 0, 1)
+    return np.clip(
+        np.stack([2 - x * 2, x * 2, np.zeros_like(x),
+                 np.ones_like(x) * alpha], -1),
+        0,
+        1,
+    )

vismatch/third_party/EDM/src/utils/profiler.py

@@ -0,0 +1,40 @@
+import torch
+from lightning.pytorch.profilers import SimpleProfiler, PassThroughProfiler
+from contextlib import contextmanager
+from lightning.pytorch.utilities import rank_zero_only
+
+
+class InferenceProfiler(SimpleProfiler):
+    """
+    This profiler records duration of actions with cuda.synchronize()
+    Use this in test time.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.start = rank_zero_only(self.start)
+        self.stop = rank_zero_only(self.stop)
+        self.summary = rank_zero_only(self.summary)
+
+    @contextmanager
+    def profile(self, action_name: str) -> None:
+        try:
+            torch.cuda.synchronize()
+            self.start(action_name)
+            yield action_name
+        finally:
+            torch.cuda.synchronize()
+            self.stop(action_name)
+
+
+def build_profiler(name):
+    if name == "inference":
+        return InferenceProfiler()
+    elif name == "pytorch":
+        from lightning.pytorch.profilers import PyTorchProfiler
+
+        return PyTorchProfiler(use_cuda=True, profile_memory=True, row_limit=100)
+    elif name is None:
+        return PassThroughProfiler()
+    else:
+        raise ValueError(f"Invalid profiler: {name}")