SYMBOL INDEX (306 symbols across 41 files)

FILE: scripts/downsample_events.py
  function _compression_opts (line 15) | def _compression_opts():
  function create_ms_to_idx (line 36) | def create_ms_to_idx(t_us):
  class H5Writer (line 44) | class H5Writer:
    method __init__ (line 45) | def __init__(self, outfile):
    method create_ms_to_idx (line 63) | def create_ms_to_idx(self):
    method close_callback (line 68) | def close_callback(h5f: h5py.File):
    method add_data (line 71) | def add_data(self, events):
  function downsample_events (line 91) | def downsample_events(events, input_height, input_width, output_height, ...
  function _filter_events_resize (line 110) | def _filter_events_resize(x, y, p, mask, change_map, fx, fy):

FILE: scripts/run_test_interframe.py
  function to_npy (line 21) | def to_npy(detections):
  function save_detections (line 34) | def save_detections(directory, detections):

FILE: scripts/train_dsec.py
  function gradients_broken (line 26) | def gradients_broken(model):
  function fix_gradients (line 36) | def fix_gradients(model):
  function train (line 42) | def train(loader: DataLoader,
  function run_test (line 77) | def run_test(loader: DataLoader,

FILE: scripts/train_ncaltech101.py
  function gradients_broken (line 25) | def gradients_broken(model):
  function fix_gradients (line 35) | def fix_gradients(model):
  function train (line 41) | def train(loader: DataLoader,
  function run_test (line 76) | def run_test(loader: DataLoader,

FILE: src/dagr/asynchronous/__init__.py
  function is_data_or_data_list (line 27) | def is_data_or_data_list(ann):
  function make_model_synchronous (line 30) | def make_model_synchronous(module: torch.nn.Module):
  function make_model_asynchronous (line 41) | def make_model_asynchronous(module, log_flops: bool = False):

FILE: src/dagr/asynchronous/base/base.py
  function add_async_graph (line 5) | def add_async_graph(module, log_flops: bool = False):
  function make_asynchronous (line 11) | def make_asynchronous(module, initialization_func, processing_func):
  function async_context (line 22) | def async_context(module, initialization_func, processing_func):

FILE: src/dagr/asynchronous/base/utils.py
  function _efficient_cat (line 7) | def _efficient_cat(data_list):
  function _efficient_cat_unique (line 13) | def _efficient_cat_unique(data_list):
  function _to_hom (line 23) | def _to_hom(x, ones=None):
  function _from_hom (line 30) | def _from_hom(x):
  function graph_new_nodes (line 33) | def graph_new_nodes(old_data, new_data):
  function graph_changed_nodes (line 36) | def graph_changed_nodes(old_data, new_data) -> Tuple[torch.Tensor, torch...
  function torch_isin (line 47) | def torch_isin(query, database):
  function __remove_duplicate_from_A (line 53) | def __remove_duplicate_from_A(a, b):

FILE: src/dagr/asynchronous/batch_norm.py
  function __sync_forward (line 9) | def __sync_forward(m, x):
  function __graph_initialization (line 13) | def __graph_initialization(module: BatchNorm, data) -> torch.Tensor:
  function __graph_processing (line 25) | def __graph_processing(module: BatchNorm, data) -> torch.Tensor:
  function __check_support (line 58) | def __check_support(module):
  function make_batch_norm_asynchronous (line 62) | def make_batch_norm_asynchronous(module: BatchNorm, log_flops: bool = Fa...

FILE: src/dagr/asynchronous/cartesian.py
  function __edge_attr (line 6) | def __edge_attr(pos, edge_index, norm, max):
  function __graph_initialization (line 19) | def __graph_initialization(module: BatchNorm, data) -> torch.Tensor:
  function __graph_processing (line 32) | def __graph_processing(module: BatchNorm, data) -> torch.Tensor:
  function __check_support (line 57) | def __check_support(module):
  function make_cartesian_asynchronous (line 61) | def make_cartesian_asynchronous(module: BatchNorm, log_flops: bool = Fal...

FILE: src/dagr/asynchronous/conv.py
  function __conv (line 11) | def __conv(x, edge_index, edge_attr, mask, nn):
  function __graph_initialization (line 28) | def __graph_initialization(module, data, *args, **kwargs):
  function __edges_with_src_node (line 60) | def __edges_with_src_node(node_idx, edge_index, edge_attr=None, node_idx...
  function find_only_x (line 91) | def find_only_x(idx_new_comp, idx_diff, pos_idx_diff, edge):
  function __graph_processing (line 94) | def __graph_processing(module, data, *args, **kwargs):
  function generalized_lin (line 229) | def generalized_lin(module, input, output, idx):
  function __check_support (line 240) | def __check_support(module) -> bool:
  function make_conv_asynchronous (line 247) | def make_conv_asynchronous(module, log_flops: bool = False):

FILE: src/dagr/asynchronous/evaluate_flops.py
  function split_data (line 10) | def split_data(data: Data, index: int)->Tuple[Data, Data]:
  function forward_hook (line 25) | def forward_hook(inst, inp, out):
  function _mask_if_possible (line 62) | def _mask_if_possible(data):
  function denorm (line 76) | def denorm(data):
  function evaluate_flops (line 82) | def evaluate_flops(model: torch.nn.Module, batch: Data, dense=False,
  function _filter_non_leaf_nodes (line 167) | def _filter_non_leaf_nodes(flops_per_layer: OrderedDict)->OrderedDict:
  function _merge_to_level_flops (line 178) | def _merge_to_level_flops(flops_per_layer: OrderedDict, level=2)->Ordere...
  function _merge_list_flops (line 192) | def _merge_list_flops(flops_per_layer_batch: List[OrderedDict])->Ordered...
  function _summary (line 195) | def _summary(est, gt, prefix):
  function max_rel_diff (line 206) | def max_rel_diff(x, y, threshold=None):
  function error_above_threshold (line 209) | def error_above_threshold(error, mag, threshold):
  function max_abs_diff (line 217) | def max_abs_diff(x, y, threshold=None, alpha=0):
  function _print_summary_for_one (line 221) | def _print_summary_for_one(target, estimate, prefix=""):
  function print_summary_of_module (line 236) | def print_summary_of_module(activations, runs=[0,2]):
  function test_and_compare_activations (line 240) | def test_and_compare_activations(model, runs=[0,2]):

FILE: src/dagr/asynchronous/flops/__init__.py
  function compute_flops_from_module (line 7) | def compute_flops_from_module(module) -> int:

FILE: src/dagr/asynchronous/flops/conv.py
  function compute_flops_conv (line 4) | def compute_flops_conv(module: torch.nn.Module, num_times_apply_bias_and...
  function compute_flops_cat (line 27) | def compute_flops_cat(module, num_edges, num_times_apply_bias_and_root, ...

FILE: src/dagr/asynchronous/linear.py
  function __graph_initialization (line 12) | def __graph_initialization(module: Linear, data) -> torch.Tensor:
  function __graph_processing (line 32) | def __graph_processing(module: Linear, data) -> torch.Tensor:
  function __check_support (line 69) | def __check_support(module: Linear):
  function make_linear_asynchronous (line 73) | def make_linear_asynchronous(module: Linear, log_flops: bool = False):

FILE: src/dagr/asynchronous/max_pool.py
  function pool_edge (line 13) | def pool_edge(cluster, edge_index, self_loop):
  function compute_attrs (line 25) | def compute_attrs(transform, edge_index, pos):
  function __dense_process (line 29) | def __dense_process(module, data: Data, *args, **kwargs) -> Data:
  function __graph_initialization (line 95) | def __graph_initialization(module, data: Data, *args, **kwargs) -> Data:
  function __graph_process (line 123) | def __graph_process(module, data, *args, **kwargs) -> Data:
  function __get_global_cluster_index (line 245) | def __get_global_cluster_index(module, pos) -> torch.LongTensor:
  function make_max_pool_asynchronous (line 255) | def make_max_pool_asynchronous(module, log_flops: bool = False):

FILE: src/dagr/data/augment.py
  function _add_event (line 14) | def _add_event(x, y, xlim, ylim, p, i, count, pos, mask, threshold=1):
  function _subsample (line 27) | def _subsample(pos: np.ndarray, polarity: np.ndarray, mask: np.ndarray, ...
  function _crop_events (line 39) | def _crop_events(data, left, right, not_crop_idx=None):
  function _crop_image (line 51) | def _crop_image(image, left, right):
  function _resize_image (line 60) | def _resize_image(image, height, width, bg=None):
  function _crop_bbox (line 78) | def _crop_bbox(bbox: torch.Tensor, left: torch.Tensor, right: torch.Tens...
  function _scale_and_clip (line 86) | def _scale_and_clip(x, scale):
  class RandomHFlip (line 90) | class RandomHFlip(BaseTransform):
    method __init__ (line 91) | def __init__(self, p: float):
    method __call__ (line 94) | def __call__(self, data: Data):
  class Crop (line 115) | class Crop(BaseTransform):
    method __init__ (line 122) | def __init__(self, min: List[float], max: List[float]):
    method init (line 126) | def init(self, height, width):
    method __call__ (line 131) | def __call__(self, data: Data):
  class RandomZoom (line 147) | class RandomZoom(BaseTransform):
    method __init__ (line 148) | def __init__(self, zoom, subsample=False):
    method _subsample (line 156) | def _subsample(self, data, zoom, count):
    method init (line 169) | def init(self, height, width):
    method __call__ (line 173) | def __call__(self, data):
  class RandomCrop (line 200) | class RandomCrop(BaseTransform):
    method __init__ (line 208) | def __init__(self, size: List[float] = [0.75, 0.75], dim: List[int]=[0...
    method init (line 213) | def init(self, height, width):
    method __call__ (line 218) | def __call__(self, data: Data):
  class RandomTranslate (line 240) | class RandomTranslate(BaseTransform):
    method __init__ (line 247) | def __init__(self, size: List[float]):
    method init (line 251) | def init(self, height, width):
    method pad (line 256) | def pad(self, image, bg):
    method __call__ (line 262) | def __call__(self, data: Data):
  class Augmentations (line 282) | class Augmentations:
    method __init__ (line 287) | def __init__(self, args):
  function init_transforms (line 296) | def init_transforms(transforms, height, width):

FILE: src/dagr/data/dsec_data.py
  function tracks_to_array (line 24) | def tracks_to_array(tracks):
  function interpolate_tracks (line 29) | def interpolate_tracks(detections_0, detections_1, t):
  class EventDirectory (line 50) | class EventDirectory(BaseDirectory):
    method event_file (line 53) | def event_file(self):
  class DSEC (line 57) | class DSEC(Dataset):
    method __init__ (line 60) | def __init__(self,
    method set_num_us (line 114) | def set_num_us(self, num_us):
    method visualize_debug (line 117) | def visualize_debug(self, index):
    method __len__ (line 132) | def __len__(self):
    method preprocess_detections (line 135) | def preprocess_detections(self, detections):
    method preprocess_events (line 141) | def preprocess_events(self, events):
    method preprocess_image (line 149) | def preprocess_image(self, image):
    method __getitem__ (line 156) | def __getitem__(self, idx):
    method rel_index (line 197) | def rel_index(self, idx):

FILE: src/dagr/data/dsec_utils.py
  function construct_pairs (line 5) | def construct_pairs(indices, n=2):
  function rescale_tracks (line 14) | def rescale_tracks(tracks, scale):
  function crop_tracks (line 20) | def crop_tracks(tracks, width, height):
  function map_classes (line 38) | def map_classes(class_ids, old_to_new_mapping):
  function filter_small_bboxes (line 43) | def filter_small_bboxes(w, h, bbox_height=20, bbox_diag=30):
  function filter_tracks (line 50) | def filter_tracks(dataset, image_width, image_height, class_remapping, m...
  function _load_events (line 80) | def _load_events(file, t0, num_events=None, num_us=None, height=None, ti...
  function filter_by_only_perfect_tracks (line 123) | def filter_by_only_perfect_tracks(tracks, img_idx_to_track_idx, tracks_m...
  function is_invalid_track (line 134) | def is_invalid_track(track):
  function compute_iou (line 150) | def compute_iou(track0, track1):
  function compute_indices_for_contiguous_parts (line 172) | def compute_indices_for_contiguous_parts(x):
  function _compute_img_idx_to_track_idx (line 177) | def _compute_img_idx_to_track_idx(t, t_query):
  function compute_img_idx_to_track_idx (line 183) | def compute_img_idx_to_track_idx(t, t_query):
  function compute_class_mapping (line 186) | def compute_class_mapping(classes, all_classes, mapping):

FILE: src/dagr/data/ncaltech101_data.py
  class NCaltech101 (line 14) | class NCaltech101(Dataset):
    method __init__ (line 16) | def __init__(self, root: Path, split, transform=Optional[Callable[[Dat...
    method __len__ (line 30) | def __len__(self):
    method preprocess (line 33) | def preprocess(self, data):
    method load_events (line 37) | def load_events(self, f_path):
    method __getitem__ (line 40) | def __getitem__(self, idx):
    method load_bboxes (line 59) | def load_bboxes(self, raw_file: Path, class_id):
  function _load_events (line 75) | def _load_events(f_path, num_events):

FILE: src/dagr/data/utils.py
  function to_data (line 6) | def to_data(**kwargs):

FILE: src/dagr/graph/ev_graph.py
  function move_to_cuda (line 5) | def move_to_cuda(func):
  class AsyncGraph (line 18) | class AsyncGraph:
    method __init__ (line 19) | def __init__(self, width=640,
    method initialize (line 45) | def initialize(self, n_ev, device):
    method reset (line 52) | def reset(self):
    method forward (line 63) | def forward(self, batch, pos, collect_edges=True):
  class SlidingWindowGraph (line 106) | class SlidingWindowGraph(AsyncGraph):
    method __init__ (line 107) | def __init__(self, width=640,
    method init (line 118) | def init(self):
    method delete_nodes (line 121) | def delete_nodes(self, n_delete, delete_edges=True, return_edges=True):
    method forward (line 139) | def forward(self, batch, pos, return_node_counts=False, return_total_e...

FILE: src/dagr/graph/spiral.h
  function class (line 1) | class SpiralOut{

FILE: src/dagr/graph/utils.py
  function _insert_events_into_queue (line 6) | def _insert_events_into_queue(batch, pos, indices, queue: torch.LongTens...
  function _search_for_edges (line 20) | def _search_for_edges(batch, pos, all_timestamps, queue, indices, max_nu...

FILE: src/dagr/model/layers/components.py
  class BatchNormData (line 9) | class BatchNormData(BatchNorm):
    method forward (line 10) | def forward(self, data: Data):
  class Linear (line 15) | class Linear(torch.nn.Module):
    method __init__ (line 16) | def __init__(self, ic, oc, bias=True):
    method forward (line 20) | def forward(self, data: Data):
  class Cartesian (line 25) | class Cartesian(torch.nn.Module):
    method __init__ (line 26) | def __init__(self, *args, **kwargs):
    method forward (line 30) | def forward(self, data):

FILE: src/dagr/model/layers/conv.py
  class ConvBlock (line 10) | class ConvBlock(torch.nn.Module):
    method __init__ (line 11) | def __init__(self, in_channels: int, out_channels: int, args, degree=1...
    method forward (line 23) | def forward(self, data: Data) -> torch.Tensor:
  class ConvBlockWithSkip (line 31) | class ConvBlockWithSkip(torch.nn.Module):
    method __init__ (line 32) | def __init__(self, in_channel: int, out_channel: int, skip_in_channel:...
    method forward (line 47) | def forward(self, data: Data, data_skip: Data):
  class Layer (line 59) | class Layer(torch.nn.Module):
    method __init__ (line 60) | def __init__(self, in_channels: int, out_channels: int, args) -> None:
    method forward (line 68) | def forward(self, data: Data) -> torch.Tensor:

FILE: src/dagr/model/layers/ev_tgn.py
  function _get_value_as_int (line 7) | def _get_value_as_int(obj, key):
  function denormalize_pos (line 11) | def denormalize_pos(events):
  class EV_TGN (line 19) | class EV_TGN(torch.nn.Module):
    method __init__ (line 20) | def __init__(self, args):
    method init_graph_creator (line 27) | def init_graph_creator(self, data):
    method forward (line 39) | def forward(self, events: Data, reset=True):

FILE: src/dagr/model/layers/pooling.py
  function consecutive_cluster (line 12) | def consecutive_cluster(src):
  class Pooling (line 19) | class Pooling(torch.nn.Module):
    method __init__ (line 20) | def __init__(self, size: List[float], width, height, batch_size, trans...
    method num_grid_cells (line 44) | def num_grid_cells(self):
    method round_to_pixel (line 47) | def round_to_pixel(self, pos, wh_inv):
    method forward (line 51) | def forward(self, data: Data):

FILE: src/dagr/model/layers/spline_conv.py
  class MySplineConv (line 9) | class MySplineConv(SplineConv):
    method __init__ (line 10) | def __init__(self, in_channels, out_channels, args, bias=False, degree...
    method init_lut (line 16) | def init_lut(self, height, width, rx=None, Mx=None, ry=None, My=None):
    method message_lut (line 39) | def message_lut(self, x_j, edge_attr):
    method forward (line 49) | def forward(self, data: Data)->Data:
    method _forward (line 64) | def _forward(self, x, edge_index, edge_attr=None, size=None):
  function to_dense (line 80) | def to_dense(self, x, pos, pooling, batch=None, batch_size=None):
  class SplineConvToDense (line 110) | class SplineConvToDense(MySplineConv):
    method forward (line 111) | def forward(self, data: Data, batch_size: int=None)->torch.Tensor:
    method to_dense (line 117) | def to_dense(self, x, pos, pooling, batch=None, batch_size=None):

FILE: src/dagr/model/networks/dagr.py
  class DAGR (line 14) | class DAGR(YOLOX):
    method __init__ (line 15) | def __init__(self, args, height, width):
    method cache_luts (line 37) | def cache_luts(self, width, height, radius):
    method forward (line 74) | def forward(self, x: Data, reset=True, return_targets=True, filtering=...
  class CNNHead (line 106) | class CNNHead(YOLOXHead):
    method forward (line 107) | def forward(self, xin):
  class GNNHead (line 125) | class GNNHead(YOLOXHead):
    method __init__ (line 126) | def __init__(
    method process_feature (line 179) | def process_feature(self, x, stem, cls_conv, reg_conv, cls_pred, reg_p...
    method forward (line 192) | def forward(self, xin: Data, labels=None, imgs=None):
    method collect_outputs (line 292) | def collect_outputs(self, cls_output, reg_output, obj_output, k, strid...
    method decode_outputs (line 306) | def decode_outputs(self, outputs, dtype):

FILE: src/dagr/model/networks/ema.py
  class ModelEMA (line 6) | class ModelEMA:
    method __init__ (line 17) | def __init__(self, model, decay=0.9999, updates=0):
    method update (line 41) | def update(self, model):

FILE: src/dagr/model/networks/net.py
  function sampling_skip (line 15) | def sampling_skip(data, image_feat):
  function compute_pooling_at_each_layer (line 19) | def compute_pooling_at_each_layer(pooling_dim_at_output, num_layers):
  class Net (line 31) | class Net(torch.nn.Module):
    method __init__ (line 32) | def __init__(self, args, height, width):
    method get_output_sizes (line 103) | def get_output_sizes(self):
    method forward (line 108) | def forward(self, data: Data, reset=True):
  function sample_features (line 193) | def sample_features(data, image_feat, image_sample_mode="bilinear"):
  function _sample_features (line 204) | def _sample_features(x, y, b, image_feat, width, height, batch_size, ima...

FILE: src/dagr/model/networks/net_img.py
  class Layer (line 4) | class Layer(torch.nn.Module):
    method __init__ (line 5) | def __init__(self, input_channels, output_channels):
    method forward (line 17) | def forward(self, x):
  class ConvBlockDense (line 25) | class ConvBlockDense(torch.nn.Module):
    method __init__ (line 26) | def __init__(self, in_channels, out_channels, bias=False, act=torch.nn...
    method forward (line 33) | def forward(self, x):
  class HookModule (line 42) | class HookModule(torch.nn.Module):
    method __init__ (line 48) | def __init__(self, module, height, width, input_channels=3, feature_la...
    method extract_layer (line 92) | def extract_layer(self, module, layer):
    method compute_channels_with_dummy (line 98) | def compute_channels_with_dummy(self, shape):
    method remove_hooks (line 106) | def remove_hooks(self):
    method register_hooks (line 110) | def register_hooks(self):
    method forward (line 122) | def forward(self, x):

FILE: src/dagr/model/utils.py
  function init_subnetwork (line 9) | def init_subnetwork(net, state_dict, name="backbone.net.", freeze=False):
  function batched_nms_coordinate_trick (line 25) | def batched_nms_coordinate_trick(boxes, scores, idxs, iou_threshold, wid...
  function convert_to_evaluation_format (line 35) | def convert_to_evaluation_format(data):
  function convert_to_training_format (line 46) | def convert_to_training_format(bbox, batch, batch_size):
  function postprocess_network_output (line 61) | def postprocess_network_output(prediction, num_classes, conf_thre=0.01, ...
  function voxel_size_to_params (line 112) | def voxel_size_to_params(pooling_layer, height, width):
  function init_grid_and_stride (line 119) | def init_grid_and_stride(hw, strides, dtype):
  function _sequential_counter (line 134) | def _sequential_counter(counts: torch.LongTensor):
  function shallow_copy (line 158) | def shallow_copy(data):

FILE: src/dagr/utils/args.py
  function BASE_FLAGS (line 7) | def BASE_FLAGS():
  function FLAGS (line 54) | def FLAGS():
  function FLOPS_FLAGS (line 82) | def FLOPS_FLAGS():
  function parse_config (line 104) | def parse_config(args: argparse.ArgumentParser, config: Path):

FILE: src/dagr/utils/buffers.py
  function diag_filter (line 10) | def diag_filter(bbox, height: int, width: int, min_box_diagonal: int = 3...
  function filter_bboxes (line 19) | def filter_bboxes(detections: List[Dict[str, torch.Tensor]], height: int...
  function format_data (line 33) | def format_data(data, normalizer=None):
  function bbox_t_to_ndarray (line 46) | def bbox_t_to_ndarray(bbox, t):
  function compile (line 68) | def compile(detections, sequences, timestamps):
  function to_cpu (line 80) | def to_cpu(data_list: List[Dict[str, torch.Tensor]]):
  class Buffer (line 83) | class Buffer:
    method __init__ (line 84) | def __init__(self):
    method extend (line 87) | def extend(self, elements: List[Dict[str, torch.Tensor]]):
    method clear (line 90) | def clear(self):
    method __iter__ (line 93) | def __iter__(self):
    method __next__ (line 96) | def __next__(self):
  class DetectionBuffer (line 101) | class DetectionBuffer:
    method __init__ (line 102) | def __init__(self, height: int, width: int, classes: List[str]):
    method compile (line 109) | def compile(self, sequences, timestamps):
    method update (line 114) | def update(self, detections: List[Dict[str, torch.Tensor]], groundtrut...
    method compute (line 118) | def compute(self)->Dict[str, float]:
  class DictBuffer (line 126) | class DictBuffer:
    method __init__ (line 127) | def __init__(self):
    method __recursive_mean (line 131) | def __recursive_mean(self, mn: float, s: float):
    method update (line 134) | def update(self, dictionary: Dict[str, float]):
    method save (line 141) | def save(self, path):
    method compute (line 144) | def compute(self)->Dict[str, float]:

FILE: src/dagr/utils/coco_eval.py
  function _convert_to_coco_format (line 17) | def _convert_to_coco_format(gt_boxes_list: List[Dict[str, Tensor]],
  function evaluate_detection (line 64) | def evaluate_detection(gt_boxes_list: List[Dict[str, Tensor]],
  function _to_prophesee (line 96) | def _to_prophesee(det: Dict[str, Tensor]):
  function _match_times (line 109) | def _match_times(all_ts, gt_boxes, dt_boxes, time_tol):
  function _coco_eval (line 147) | def _coco_eval(dataset, results, num_gts):
  function _to_coco_format (line 181) | def _to_coco_format(gts, detections, categories, height=240, width=304):

FILE: src/dagr/utils/learning_rate_scheduler.py
  class LRSchedule (line 8) | class LRSchedule:
    method __init__ (line 9) | def __init__(self,
    method __call__ (line 23) | def __call__(self, *args, **kwargs)->float:
  function _yolox_warm_cos_lr (line 27) | def _yolox_warm_cos_lr(

FILE: src/dagr/utils/logging.py
  class Checkpointer (line 14) | class Checkpointer:
    method __init__ (line 15) | def __init__(self, output_directory: Optional[Path] = None, args=None,...
    method restore_if_existing (line 25) | def restore_if_existing(self, folder, resume_from_best=False):
    method mAP_from_checkpoint_name (line 31) | def mAP_from_checkpoint_name(self, checkpoint_name: Path):
    method search_for_checkpoint (line 34) | def search_for_checkpoint(self, resume_checkpoint: Path, best=False):
    method restore_if_not_none (line 51) | def restore_if_not_none(self, target, source):
    method restore_checkpoint (line 55) | def restore_checkpoint(self, checkpoint_directory, best=False):
    method fix_checkpoint (line 72) | def fix_checkpoint(self, state_dict):
    method checkpoint (line 75) | def checkpoint(self, epoch: int, name: str=""):
    method process (line 90) | def process(self, data: Dict[str, float], epoch: int):
  function set_up_logging_directory (line 101) | def set_up_logging_directory(dataset, task, output_directory, exp_name="...
  function log_hparams (line 114) | def log_hparams(args):
  function log_bboxes (line 119) | def log_bboxes(data: Batch,
  function visualize_events (line 169) | def visualize_events(data: Data)->torch.Tensor:
  function __convert_to_wandb_data (line 184) | def __convert_to_wandb_data(image: torch.Tensor, gt: torch.Tensor, p: to...
  function __parse_bboxes (line 190) | def __parse_bboxes(bboxes: torch.Tensor, class_names: List[str], suffix:...
  function __parse_bbox (line 197) | def __parse_bbox(bbox: torch.Tensor, class_names: List[str], suffix: str...

FILE: src/dagr/utils/testing.py
  function to_npy (line 6) | def to_npy(detections):
  function format_detections (line 9) | def format_detections(sequences, t, detections):
  function run_test_with_visualization (line 16) | def run_test_with_visualization(loader, model, dataset: str, log_every_n...

FILE: src/dagr/visualization/bbox_viz.py
  function draw_bbox_on_img (line 11) | def draw_bbox_on_img(img, x, y, w, h, labels, scores=None, conf=0.5, nms...
  function filter_boxes (line 56) | def filter_boxes(x, y, w, h, labels, scores, conf, nms):

FILE: src/dagr/visualization/event_viz.py
  function draw_events_on_image (line 4) | def draw_events_on_image(img, x, y, p, alpha=0.5):