code: def run(model: BaseModel, dataset: BaseDataset, device, cfg):
      print(time.strftime("%Y%m%d-%H%M%S"))
      dataset.create_dataloaders(
          model,
          1,
          False,
          cfg.training.num_workers,
          False,
      )
      loader = dataset.test_dataset[0]
  
      ind = 0
      if cfg.ind is not None:
          ind = cfg.ind
      t = 5
      if cfg.t is not None:
          t = cfg.t
      r = 0.1
      if cfg.r is not None:
          r = cfg.r
      print(loader)
      print(ind)
      data = loader[ind]
      data.batch = torch.zeros(len(data.pos)).long()
      data.batch_target = torch.zeros(len(data.pos_target)).long()
      print(data)
      with torch.no_grad():
          model.set_input(data, device)
          model.forward()
  
          (
              name_scene,
              name_pair_source,
              name_pair_target,
          ) = dataset.test_dataset[0].get_name(ind)
          print(name_scene, name_pair_source, name_pair_target)
          input, input_target = model.get_input()
          xyz, xyz_target = input.pos, input_target.pos
          ind, ind_target = input.ind, input_target.ind
          matches_gt = torch.stack([ind, ind_target]).transpose(0, 1)
          feat, feat_target = model.get_output()
          # rand = voxel_selection(xyz, grid_size=0.06, min_points=cfg.data.min_points)
          # rand_target = voxel_selection(xyz_target, grid_size=0.06, min_points=cfg.data.min_points)
  
          rand = torch.randperm(len(feat))[: cfg.data.num_points]
          rand_target = torch.randperm(len(feat_target))[
              : cfg.data.num_points
          ]
          T_gt = estimate_transfo(
              xyz[matches_gt[:, 0]].clone(),
              xyz_target[matches_gt[:, 1]].clone(),
          )
          matches_pred = get_matches(
              feat[rand], feat_target[rand_target], sym=cfg.data.sym
          )
          # For color
          inliers = (
              torch.norm(
                  xyz[rand][matches_pred[:, 0]] @ T_gt[:3, :3].T
                  + T_gt[:3, 3]
                  - xyz_target[rand_target][matches_pred[:, 1]],
                  dim=1,
              )
              < cfg.data.tau_1
          )
          # compute transformation
          T_teaser = teaser_pp_registration(
              xyz[rand][matches_pred[:, 0]],
              xyz_target[rand_target][matches_pred[:, 1]],
              noise_bound=cfg.data.tau_1,
          )
          pcd_source = torch2o3d(input, [1, 0.7, 0.1])
  
          pcd_target = torch2o3d(input_target, [0, 0.15, 0.9])
          open3d.visualization.draw_geometries([pcd_source, pcd_target])
          pcd_source.transform(T_teaser.cpu().numpy())
          open3d.visualization.draw_geometries([pcd_source, pcd_target])
          pcd_source.transform(np.linalg.inv(T_teaser.cpu().numpy()))
          rand_ind = torch.randperm(len(rand[matches_pred[:, 0]]))[:250]
          pcd_source.transform(T_gt.cpu().numpy())
          kp_s = torch2o3d(
              input, ind=rand[matches_pred[:, 0]][rand_ind]
          )
          kp_s.transform(T_gt.cpu().numpy())
          kp_t = torch2o3d(
              input_target,
              ind=rand_target[matches_pred[:, 1]][rand_ind],
          )
          match_visualizer(
              pcd_source,
              kp_s,
              pcd_target,
              kp_t,
              inliers[rand_ind].cpu().numpy(),
              radius=r,
              t=t,
          )
  
imports: import open3d
  import torch
  import numpy
  import hydra
  import logging
  from omegaconf import OmegaConf
  import os
  import sys
  import pandas
  import time
  from torch_points3d.models.model_factory import instantiate_model
  from torch_points3d.datasets.dataset_factory import instantiate_dataset, get_dataset_class
  from torch_points3d.models.base_model import BaseModel
  from torch_points3d.datasets.base_dataset import BaseDataset
  from torch_points3d.utils.registration import estimate_transfo, teaser_pp_registration, fast_global_registration, get_matches
  from torch_points3d.metrics.registration_metrics import compute_hit_ratio, compute_transfo_error, compute_scaled_registration_error
  from torch_points3d.metrics.colored_tqdm import Coloredtqdm
  from torch_points3d.metrics.model_checkpoint import ModelCheckpoint
label_desc: Use image node_id 5 for calling a global function with example usage: run(model, dataset, device, cfg) without return types