SYMBOL INDEX (891 symbols across 79 files)

FILE: ava_evaluation/label_map_util.py
  function _validate_label_map (line 25) | def _validate_label_map(label_map):
  function create_category_index (line 39) | def create_category_index(categories):
  function get_max_label_map_index (line 58) | def get_max_label_map_index(label_map):
  function convert_label_map_to_categories (line 70) | def convert_label_map_to_categories(label_map, max_num_classes, use_disp...
  function load_labelmap (line 122) | def load_labelmap(path):
  function get_label_map_dict (line 141) | def get_label_map_dict(label_map_path, use_display_name=False):
  function create_category_index_from_labelmap (line 161) | def create_category_index_from_labelmap(label_map_path):
  function create_class_agnostic_category_index (line 178) | def create_class_agnostic_category_index():

FILE: ava_evaluation/metrics.py
  function compute_precision_recall (line 23) | def compute_precision_recall(scores, labels, num_gt):
  function compute_average_precision (line 74) | def compute_average_precision(precision, recall):
  function compute_cor_loc (line 126) | def compute_cor_loc(num_gt_imgs_per_class, num_images_correctly_detected...

FILE: ava_evaluation/np_box_list.py
  class BoxList (line 23) | class BoxList:
    method __init__ (line 35) | def __init__(self, data):
    method num_boxes (line 58) | def num_boxes(self):
    method get_extra_fields (line 62) | def get_extra_fields(self):
    method has_field (line 66) | def has_field(self, field):
    method add_field (line 69) | def add_field(self, field, field_data):
    method get (line 86) | def get(self):
    method get_field (line 94) | def get_field(self, field):
    method get_coordinates (line 110) | def get_coordinates(self):
    method _is_valid_boxes (line 123) | def _is_valid_boxes(self, data):

FILE: ava_evaluation/np_box_list_ops.py
  class SortOrder (line 30) | class SortOrder:
  function area (line 42) | def area(boxlist):
  function intersection (line 55) | def intersection(boxlist1, boxlist2):
  function iou (line 68) | def iou(boxlist1, boxlist2):
  function ioa (line 81) | def ioa(boxlist1, boxlist2):
  function gather (line 98) | def gather(boxlist, indices, fields=None):
  function sort_by_field (line 133) | def sort_by_field(boxlist, field, order=SortOrder.DESCEND):
  function non_max_suppression (line 164) | def non_max_suppression(
  function multi_class_non_max_suppression (line 239) | def multi_class_non_max_suppression(boxlist, score_thresh, iou_thresh, m...
  function scale (line 316) | def scale(boxlist, y_scale, x_scale):
  function clip_to_window (line 342) | def clip_to_window(boxlist, window):
  function prune_non_overlapping_boxes (line 378) | def prune_non_overlapping_boxes(boxlist1, boxlist2, minoverlap=0.0):
  function prune_outside_window (line 401) | def prune_outside_window(boxlist, window):
  function concatenate (line 439) | def concatenate(boxlists, fields=None):
  function filter_scores_greater_than (line 492) | def filter_scores_greater_than(boxlist, thresh):
  function change_coordinate_frame (line 527) | def change_coordinate_frame(boxlist, window):
  function _copy_extra_fields (line 560) | def _copy_extra_fields(boxlist_to_copy_to, boxlist_to_copy_from):
  function _update_valid_indices_by_removing_high_iou_boxes (line 575) | def _update_valid_indices_by_removing_high_iou_boxes(

FILE: ava_evaluation/np_box_mask_list.py
  class BoxMaskList (line 25) | class BoxMaskList(np_box_list.BoxList):
    method __init__ (line 33) | def __init__(self, box_data, mask_data):
    method get_masks (line 59) | def get_masks(self):

FILE: ava_evaluation/np_box_mask_list_ops.py
  function box_list_to_box_mask_list (line 30) | def box_list_to_box_mask_list(boxlist):
  function area (line 54) | def area(box_mask_list):
  function intersection (line 66) | def intersection(box_mask_list1, box_mask_list2):
  function iou (line 81) | def iou(box_mask_list1, box_mask_list2):
  function ioa (line 94) | def ioa(box_mask_list1, box_mask_list2):
  function gather (line 111) | def gather(box_mask_list, indices, fields=None):
  function sort_by_field (line 142) | def sort_by_field(box_mask_list, field, order=np_box_list_ops.SortOrder....
  function non_max_suppression (line 161) | def non_max_suppression(
  function multi_class_non_max_suppression (line 242) | def multi_class_non_max_suppression(
  function prune_non_overlapping_masks (line 324) | def prune_non_overlapping_masks(box_mask_list1, box_mask_list2, minoverl...
  function concatenate (line 348) | def concatenate(box_mask_lists, fields=None):
  function filter_scores_greater_than (line 378) | def filter_scores_greater_than(box_mask_list, thresh):

FILE: ava_evaluation/np_box_ops.py
  function area (line 28) | def area(boxes):
  function intersection (line 40) | def intersection(boxes1, boxes2):
  function iou (line 68) | def iou(boxes1, boxes2):
  function ioa (line 85) | def ioa(boxes1, boxes2):

FILE: ava_evaluation/np_mask_ops.py
  function area (line 30) | def area(masks):
  function intersection (line 48) | def intersection(masks1, masks2):
  function iou (line 74) | def iou(masks1, masks2):
  function ioa (line 98) | def ioa(masks1, masks2):

FILE: ava_evaluation/object_detection_evaluation.py
  class DetectionEvaluator (line 41) | class DetectionEvaluator:
    method __init__ (line 61) | def __init__(self, categories):
    method add_single_ground_truth_image_info (line 72) | def add_single_ground_truth_image_info(self, image_id, groundtruth_dict):
    method add_single_detected_image_info (line 83) | def add_single_detected_image_info(self, image_id, detections_dict):
    method evaluate (line 94) | def evaluate(self):
    method clear (line 99) | def clear(self):
  class ObjectDetectionEvaluator (line 104) | class ObjectDetectionEvaluator(DetectionEvaluator):
    method __init__ (line 107) | def __init__(
    method add_single_ground_truth_image_info (line 155) | def add_single_ground_truth_image_info(self, image_id, groundtruth_dict):
    method add_single_detected_image_info (line 229) | def add_single_detected_image_info(self, image_id, detections_dict):
    method evaluate (line 276) | def evaluate(self):
    method clear (line 331) | def clear(self):
  class PascalDetectionEvaluator (line 342) | class PascalDetectionEvaluator(ObjectDetectionEvaluator):
    method __init__ (line 345) | def __init__(self, categories, matching_iou_threshold=0.5):
  class WeightedPascalDetectionEvaluator (line 355) | class WeightedPascalDetectionEvaluator(ObjectDetectionEvaluator):
    method __init__ (line 369) | def __init__(self, categories, matching_iou_threshold=0.5):
  class PascalInstanceSegmentationEvaluator (line 379) | class PascalInstanceSegmentationEvaluator(ObjectDetectionEvaluator):
    method __init__ (line 382) | def __init__(self, categories, matching_iou_threshold=0.5):
  class WeightedPascalInstanceSegmentationEvaluator (line 393) | class WeightedPascalInstanceSegmentationEvaluator(ObjectDetectionEvaluat...
    method __init__ (line 407) | def __init__(self, categories, matching_iou_threshold=0.5):
  class OpenImagesDetectionEvaluator (line 418) | class OpenImagesDetectionEvaluator(ObjectDetectionEvaluator):
    method __init__ (line 425) | def __init__(self, categories, matching_iou_threshold=0.5, evaluate_co...
    method add_single_ground_truth_image_info (line 443) | def add_single_ground_truth_image_info(self, image_id, groundtruth_dict):
  class ObjectDetectionEvaluation (line 515) | class ObjectDetectionEvaluation:
    method __init__ (line 518) | def __init__(
    method _initialize_detections (line 548) | def _initialize_detections(self):
    method clear_detections (line 559) | def clear_detections(self):
    method add_single_ground_truth_image_info (line 562) | def add_single_ground_truth_image_info(
    method add_single_detected_image_info (line 619) | def add_single_detected_image_info(
    method _update_ground_truth_statistics (line 704) | def _update_ground_truth_statistics(
    method evaluate (line 736) | def evaluate(self):

FILE: ava_evaluation/per_image_evaluation.py
  class PerImageEvaluation (line 31) | class PerImageEvaluation:
    method __init__ (line 34) | def __init__(self, num_groundtruth_classes, matching_iou_threshold=0.5):
    method compute_object_detection_metrics (line 45) | def compute_object_detection_metrics(
    method _compute_tp_fp (line 120) | def _compute_tp_fp(
    method _get_overlaps_and_scores_box_mode (line 215) | def _get_overlaps_and_scores_box_mode(
    method _compute_tp_fp_for_single_class (line 253) | def _compute_tp_fp_for_single_class(
    method _get_ith_class_arrays (line 344) | def _get_ith_class_arrays(
    method _remove_invalid_boxes (line 401) | def _remove_invalid_boxes(

FILE: ava_evaluation/standard_fields.py
  class InputDataFields (line 29) | class InputDataFields:
  class DetectionResultFields (line 94) | class DetectionResultFields:
  class BoxListFields (line 120) | class BoxListFields:
  class TfExampleFields (line 146) | class TfExampleFields:

FILE: slowfast/config/custom_config.py
  function add_custom_config (line 7) | def add_custom_config(_C):

FILE: slowfast/config/defaults.py
  function assert_and_infer_cfg (line 1263) | def assert_and_infer_cfg(cfg):
  function get_cfg (line 1291) | def get_cfg():

FILE: slowfast/datasets/ava_dataset.py
  class Ava (line 21) | class Ava(torch.utils.data.Dataset):
    method __init__ (line 26) | def __init__(self, cfg, split):
    method _load_data (line 52) | def _load_data(self, cfg):
    method print_summary (line 88) | def print_summary(self):
    method __len__ (line 99) | def __len__(self):
    method num_videos (line 107) | def num_videos(self):
    method _images_and_boxes_preprocessing_cv2 (line 114) | def _images_and_boxes_preprocessing_cv2(self, imgs, boxes):
    method _images_and_boxes_preprocessing (line 238) | def _images_and_boxes_preprocessing(self, imgs, boxes):
    method __getitem__ (line 339) | def __getitem__(self, idx):

FILE: slowfast/datasets/ava_helper.py
  function load_image_lists (line 16) | def load_image_lists(cfg, is_train):
  function load_boxes_and_labels (line 63) | def load_boxes_and_labels(cfg, mode):
  function get_keyframe_data (line 107) | def get_keyframe_data(boxes_and_labels):
  function get_num_boxes_used (line 151) | def get_num_boxes_used(keyframe_indices, keyframe_boxes_and_labels):
  function parse_bboxes_file (line 170) | def parse_bboxes_file(ann_filenames, ann_is_gt_box, detect_thresh, boxes...

FILE: slowfast/datasets/build.py
  function build_dataset (line 15) | def build_dataset(dataset_name, cfg, split):

FILE: slowfast/datasets/charades.py
  class Charades (line 20) | class Charades(torch.utils.data.Dataset):
    method __init__ (line 31) | def __init__(self, cfg, mode, num_retries=10):
    method _construct_loader (line 72) | def _construct_loader(self):
    method get_seq_frames (line 107) | def get_seq_frames(self, index):
    method __getitem__ (line 147) | def __getitem__(self, index):
    method __len__ (line 233) | def __len__(self):
    method num_videos (line 241) | def num_videos(self):

FILE: slowfast/datasets/cv2_transform.py
  function clip_boxes_to_image (line 10) | def clip_boxes_to_image(boxes, height, width):
  function random_short_side_scale_jitter_list (line 26) | def random_short_side_scale_jitter_list(images, min_size, max_size, boxe...
  function scale (line 70) | def scale(size, image):
  function scale_boxes (line 95) | def scale_boxes(size, boxes, height, width):
  function horizontal_flip_list (line 121) | def horizontal_flip_list(prob, images, order="CHW", boxes=None):
  function spatial_shift_crop_list (line 153) | def spatial_shift_crop_list(size, images, spatial_shift_pos, boxes=None):
  function CHW2HWC (line 203) | def CHW2HWC(image):
  function HWC2CHW (line 215) | def HWC2CHW(image):
  function color_jitter_list (line 227) | def color_jitter_list(images, img_brightness=0, img_contrast=0, img_satu...
  function lighting_list (line 258) | def lighting_list(imgs, alphastd, eigval, eigvec, alpha=None):
  function color_normalization (line 287) | def color_normalization(image, mean, stddev):
  function pad_image (line 304) | def pad_image(image, pad_size, order="CHW"):
  function horizontal_flip (line 329) | def horizontal_flip(prob, image, order="CHW"):
  function flip_boxes (line 350) | def flip_boxes(boxes, im_width):
  function crop_boxes (line 366) | def crop_boxes(boxes, x_offset, y_offset):
  function random_crop_list (line 379) | def random_crop_list(images, size, pad_size=0, order="CHW", boxes=None):
  function center_crop (line 442) | def center_crop(size, image):
  function random_scale_jitter (line 461) | def random_scale_jitter(image, min_size, max_size):
  function random_scale_jitter_list (line 477) | def random_scale_jitter_list(images, min_size, max_size):
  function random_sized_crop (line 493) | def random_sized_crop(image, size, area_frac=0.08):
  function lighting (line 532) | def lighting(img, alphastd, eigval, eigvec):
  function random_sized_crop_list (line 558) | def random_sized_crop_list(images, size, crop_area_fraction=0.08):
  function blend (line 606) | def blend(image1, image2, alpha):
  function grayscale (line 610) | def grayscale(image):
  function saturation (line 628) | def saturation(var, image):
  function brightness (line 642) | def brightness(var, image):
  function contrast (line 656) | def contrast(var, image):
  function saturation_list (line 671) | def saturation_list(var, images):
  function brightness_list (line 689) | def brightness_list(var, images):
  function contrast_list (line 707) | def contrast_list(var, images):
  function color_jitter (line 726) | def color_jitter(image, img_brightness=0, img_contrast=0, img_saturation...
  function revert_scaled_boxes (line 757) | def revert_scaled_boxes(size, boxes, img_height, img_width):

FILE: slowfast/datasets/decoder.py
  function temporal_sampling (line 17) | def temporal_sampling(frames, start_idx, end_idx, num_samples):
  function get_start_end_idx (line 37) | def get_start_end_idx(
  function get_multiple_start_end_idx (line 79) | def get_multiple_start_end_idx(
  function pyav_decode_stream (line 186) | def pyav_decode_stream(
  function torchvision_decode (line 228) | def torchvision_decode(
  function pyav_decode (line 373) | def pyav_decode(
  function decode (line 452) | def decode(

FILE: slowfast/datasets/imagenet.py
  class Imagenet (line 27) | class Imagenet(torch.utils.data.Dataset):
    method __init__ (line 30) | def __init__(self, cfg, mode, num_retries=10):
    method _load_imdb (line 49) | def _load_imdb(self):
    method _construct_imdb (line 57) | def _construct_imdb(self):
    method load_image (line 78) | def load_image(self, im_path):
    method _prepare_im_res (line 88) | def _prepare_im_res(self, im_path):
    method _prepare_im_tf (line 121) | def _prepare_im_tf(self, im_path):
    method _prepare_im_masked (line 168) | def _prepare_im_masked(self, im_path):
    method __load__ (line 211) | def __load__(self, index):
    method __getitem__ (line 234) | def __getitem__(self, index):
    method __len__ (line 267) | def __len__(self):

FILE: slowfast/datasets/kinetics.py
  class Kinetics (line 29) | class Kinetics(torch.utils.data.Dataset):
    method __init__ (line 40) | def __init__(self, cfg, mode, num_retries=100):
    method _construct_loader (line 102) | def _construct_loader(self):
    method _set_epoch_num (line 156) | def _set_epoch_num(self, epoch):
    method _get_chunk (line 159) | def _get_chunk(self, path_to_file, chunksize):
    method __getitem__ (line 174) | def __getitem__(self, index):
    method _gen_mask (line 470) | def _gen_mask(self):
    method _frame_to_list_img (line 506) | def _frame_to_list_img(self, frames):
    method _list_img_to_frames (line 510) | def _list_img_to_frames(self, img_list):
    method __len__ (line 514) | def __len__(self):
    method num_videos (line 522) | def num_videos(self):

FILE: slowfast/datasets/loader.py
  function multiple_samples_collate (line 20) | def multiple_samples_collate(batch, fold=False):
  function detection_collate (line 48) | def detection_collate(batch):
  function construct_loader (line 86) | def construct_loader(cfg, split, is_precise_bn=False):
  function shuffle_dataset (line 174) | def shuffle_dataset(loader, cur_epoch):

FILE: slowfast/datasets/mixup.py
  function convert_to_one_hot (line 22) | def convert_to_one_hot(targets, num_classes, on_value=1.0, off_value=0.0):
  function mixup_target (line 40) | def mixup_target(target, num_classes, lam=1.0, smoothing=0.0):
  function rand_bbox (line 67) | def rand_bbox(img_shape, lam, margin=0.0, count=None):
  function get_cutmix_bbox (line 90) | def get_cutmix_bbox(img_shape, lam, correct_lam=True, count=None):
  class MixUp (line 109) | class MixUp:
    method __init__ (line 117) | def __init__(
    method _get_mixup_params (line 148) | def _get_mixup_params(self):
    method _mix_batch (line 167) | def _mix_batch(self, x):
    method __call__ (line 183) | def __call__(self, x, target):

FILE: slowfast/datasets/multigrid_helper.py
  class ShortCycleBatchSampler (line 19) | class ShortCycleBatchSampler(Sampler):
    method __init__ (line 26) | def __init__(self, sampler, batch_size, drop_last, cfg):
    method __iter__ (line 66) | def __iter__(self):
    method __len__ (line 80) | def __len__(self):

FILE: slowfast/datasets/ptv_datasets.py
  class PTVDatasetWrapper (line 32) | class PTVDatasetWrapper(torch.utils.data.IterableDataset):
    method __init__ (line 37) | def __init__(self, num_videos, clips_per_video, crops_per_clip, dataset):
    method __next__ (line 51) | def __next__(self):
    method sampler (line 58) | def sampler(self):
    method __len__ (line 65) | def __len__(self):
    method num_videos (line 73) | def num_videos(self):
    method __iter__ (line 80) | def __iter__(self):
  class PackPathway (line 84) | class PackPathway(torch.nn.Module):
    method __init__ (line 90) | def __init__(self, cfg):
    method forward (line 94) | def forward(self, x: torch.Tensor):
  class DictToTuple (line 98) | class DictToTuple(torch.nn.Module):
    method __init__ (line 104) | def __init__(self, num_clips, num_crops):
    method forward (line 109) | def forward(self, x: Dict[str, torch.Tensor]):
  function div255 (line 119) | def div255(x):
  function Ptvkinetics (line 133) | def Ptvkinetics(cfg, mode):
  function process_charades_label (line 255) | def process_charades_label(x, mode, num_classes):
  function rgb2bgr (line 274) | def rgb2bgr(x):
  function Ptvcharades (line 288) | def Ptvcharades(cfg, mode):
  function Ptvssv2 (line 427) | def Ptvssv2(cfg, mode):

FILE: slowfast/datasets/rand_augment.py
  function _interpolation (line 53) | def _interpolation(kwargs):
  function _check_args_tf (line 61) | def _check_args_tf(kwargs):
  function shear_x (line 67) | def shear_x(img, factor, **kwargs):
  function shear_y (line 72) | def shear_y(img, factor, **kwargs):
  function translate_x_rel (line 77) | def translate_x_rel(img, pct, **kwargs):
  function translate_y_rel (line 83) | def translate_y_rel(img, pct, **kwargs):
  function translate_x_abs (line 89) | def translate_x_abs(img, pixels, **kwargs):
  function translate_y_abs (line 94) | def translate_y_abs(img, pixels, **kwargs):
  function rotate (line 99) | def rotate(img, degrees, **kwargs):
  function auto_contrast (line 133) | def auto_contrast(img, **__):
  function invert (line 137) | def invert(img, **__):
  function equalize (line 141) | def equalize(img, **__):
  function solarize (line 145) | def solarize(img, thresh, **__):
  function solarize_add (line 149) | def solarize_add(img, add, thresh=128, **__):
  function posterize (line 164) | def posterize(img, bits_to_keep, **__):
  function contrast (line 170) | def contrast(img, factor, **__):
  function color (line 174) | def color(img, factor, **__):
  function brightness (line 178) | def brightness(img, factor, **__):
  function sharpness (line 182) | def sharpness(img, factor, **__):
  function _randomly_negate (line 186) | def _randomly_negate(v):
  function _rotate_level_to_arg (line 191) | def _rotate_level_to_arg(level, _hparams):
  function _enhance_level_to_arg (line 198) | def _enhance_level_to_arg(level, _hparams):
  function _enhance_increasing_level_to_arg (line 203) | def _enhance_increasing_level_to_arg(level, _hparams):
  function _shear_level_to_arg (line 211) | def _shear_level_to_arg(level, _hparams):
  function _translate_abs_level_to_arg (line 218) | def _translate_abs_level_to_arg(level, hparams):
  function _translate_rel_level_to_arg (line 225) | def _translate_rel_level_to_arg(level, hparams):
  function _posterize_level_to_arg (line 233) | def _posterize_level_to_arg(level, _hparams):
  function _posterize_increasing_level_to_arg (line 240) | def _posterize_increasing_level_to_arg(level, hparams):
  function _posterize_original_level_to_arg (line 247) | def _posterize_original_level_to_arg(level, _hparams):
  function _solarize_level_to_arg (line 254) | def _solarize_level_to_arg(level, _hparams):
  function _solarize_increasing_level_to_arg (line 260) | def _solarize_increasing_level_to_arg(level, _hparams):
  function _solarize_add_level_to_arg (line 266) | def _solarize_add_level_to_arg(level, _hparams):
  class AugmentOp (line 328) | class AugmentOp:
    method __init__ (line 333) | def __init__(self, name, prob=0.5, magnitude=10, hparams=None):
    method __call__ (line 355) | def __call__(self, img_list):
  function _select_rand_weights (line 431) | def _select_rand_weights(weight_idx=0, transforms=None):
  function rand_augment_ops (line 440) | def rand_augment_ops(magnitude=10, hparams=None, transforms=None):
  class RandAugment (line 449) | class RandAugment:
    method __init__ (line 450) | def __init__(self, ops, num_layers=2, choice_weights=None):
    method __call__ (line 455) | def __call__(self, img):
  function rand_augment_transform (line 468) | def rand_augment_transform(config_str, hparams):

FILE: slowfast/datasets/random_erasing.py
  function _get_pixels (line 20) | def _get_pixels(per_pixel, rand_color, patch_size, dtype=torch.float32, ...
  class RandomErasing (line 32) | class RandomErasing:
    method __init__ (line 51) | def __init__(
    method _erase (line 85) | def _erase(self, img, chan, img_h, img_w, dtype):
    method _erase_cube (line 114) | def _erase_cube(
    method __call__ (line 154) | def __call__(self, input):

FILE: slowfast/datasets/ssv2.py
  class Ssv2 (line 22) | class Ssv2(torch.utils.data.Dataset):
    method __init__ (line 33) | def __init__(self, cfg, mode, num_retries=10):
    method _construct_loader (line 81) | def _construct_loader(self):
    method get_seq_frames (line 159) | def get_seq_frames(self, index):
    method __getitem__ (line 182) | def __getitem__(self, index):
    method __len__ (line 305) | def __len__(self):
    method num_videos (line 313) | def num_videos(self):

FILE: slowfast/datasets/transform.py
  function _pil_interp (line 34) | def _pil_interp(method):
  function random_short_side_scale_jitter (line 48) | def random_short_side_scale_jitter(
  function crop_boxes (line 101) | def crop_boxes(boxes, x_offset, y_offset):
  function random_crop (line 120) | def random_crop(images, size, boxes=None):
  function horizontal_flip (line 152) | def horizontal_flip(prob, images, boxes=None):
  function uniform_crop (line 187) | def uniform_crop(images, size, spatial_idx, boxes=None, scale_size=None):
  function clip_boxes_to_image (line 246) | def clip_boxes_to_image(boxes, height, width):
  function blend (line 268) | def blend(images1, images2, alpha):
  function grayscale (line 284) | def grayscale(images):
  function color_jitter (line 304) | def color_jitter(images, img_brightness=0, img_contrast=0, img_saturatio...
  function brightness_jitter (line 339) | def brightness_jitter(var, images):
  function contrast_jitter (line 358) | def contrast_jitter(var, images):
  function saturation_jitter (line 378) | def saturation_jitter(var, images):
  function lighting_jitter (line 397) | def lighting_jitter(images, alphastd, eigval, eigvec):
  function color_normalization (line 443) | def color_normalization(images, mean, stddev):
  function _get_param_spatial_crop (line 477) | def _get_param_spatial_crop(
  function random_resized_crop (line 519) | def random_resized_crop(
  function random_resized_crop_with_shift (line 554) | def random_resized_crop_with_shift(
  function create_random_augment (line 599) | def create_random_augment(
  function random_sized_crop_img (line 633) | def random_sized_crop_img(
  class RandomResizedCropAndInterpolation (line 666) | class RandomResizedCropAndInterpolation:
    method __init__ (line 679) | def __init__(
    method get_params (line 701) | def get_params(img, scale, ratio):
    method __call__ (line 741) | def __call__(self, img):
    method __repr__ (line 755) | def __repr__(self):
  class MaskingGenerator (line 776) | class MaskingGenerator:
    method __init__ (line 777) | def __init__(
    method __repr__ (line 807) | def __repr__(self):
    method get_shape (line 819) | def get_shape(self):
    method _mask (line 822) | def _mask(self, mask, max_mask_patches):
    method __call__ (line 846) | def __call__(self):
  class MaskingGenerator3D (line 869) | class MaskingGenerator3D:
    method __init__ (line 870) | def __init__(
    method __repr__ (line 888) | def __repr__(self):
    method get_shape (line 901) | def get_shape(self):
    method _mask (line 904) | def _mask(self, mask, max_mask_patches):
    method __call__ (line 933) | def __call__(self):
  function transforms_imagenet_train (line 948) | def transforms_imagenet_train(
  function temporal_difference (line 1047) | def temporal_difference(
  function color_jitter_video_ssl (line 1073) | def color_jitter_video_ssl(
  function augment_raw_frames (line 1124) | def augment_raw_frames(frames, time_diff_prob=0.0, gaussian_prob=0.0):
  class GaussianBlur (line 1145) | class GaussianBlur:
    method __init__ (line 1148) | def __init__(self, sigma=[0.1, 2.0]):
    method __call__ (line 1151) | def __call__(self, x):
  class GaussianBlurVideo (line 1160) | class GaussianBlurVideo:
    method __init__ (line 1161) | def __init__(self, sigma_min=[0.0, 0.1], sigma_max=[0.0, 2.0], use_PIL...
    method __call__ (line 1165) | def __call__(self, frames):

FILE: slowfast/datasets/utils.py
  function retry_load_images (line 24) | def retry_load_images(image_paths, retry=10, backend="pytorch"):
  function get_sequence (line 55) | def get_sequence(center_idx, half_len, sample_rate, num_frames):
  function pack_pathway_output (line 78) | def pack_pathway_output(cfg, frames):
  function spatial_sampling (line 114) | def spatial_sampling(
  function as_binary_vector (line 188) | def as_binary_vector(labels, num_classes):
  function aggregate_labels (line 204) | def aggregate_labels(label_list):
  function convert_to_video_level_labels (line 219) | def convert_to_video_level_labels(labels):
  function load_image_lists (line 235) | def load_image_lists(frame_list_file, prefix="", return_list=False):
  function tensor_normalize (line 278) | def tensor_normalize(tensor, mean, std, func=None):
  function get_random_sampling_rate (line 300) | def get_random_sampling_rate(long_cycle_sampling_rate, sampling_rate):
  function revert_tensor_normalize (line 312) | def revert_tensor_normalize(tensor, mean, std):
  function create_sampler (line 329) | def create_sampler(dataset, shuffle, cfg):
  function loader_worker_init_fn (line 346) | def loader_worker_init_fn(dataset):
  function aug_frame (line 355) | def aug_frame(
  function _frame_to_list_img (line 437) | def _frame_to_list_img(frames):
  function _list_img_to_frames (line 442) | def _list_img_to_frames(img_list):

FILE: slowfast/datasets/video_container.py
  function get_video_container (line 7) | def get_video_container(path_to_vid, multi_thread_decode=False, backend=...

FILE: slowfast/models/attention.py
  function attention_pool (line 13) | def attention_pool(tensor, pool, thw_shape, has_cls_embed=True, norm=None):
  function get_rel_pos (line 48) | def get_rel_pos(rel_pos, d):
  function cal_rel_pos_spatial (line 64) | def cal_rel_pos_spatial(
  function cal_rel_pos_temporal (line 111) | def cal_rel_pos_temporal(attn, q, has_cls_embed, q_shape, k_shape, rel_p...
  class MultiScaleAttention (line 150) | class MultiScaleAttention(nn.Module):
    method __init__ (line 151) | def __init__(
    method forward (line 293) | def forward(self, x, thw_shape):
  class MultiScaleBlock (line 395) | class MultiScaleBlock(nn.Module):
    method __init__ (line 396) | def __init__(
    method forward (line 491) | def forward(self, x, thw_shape=None):

FILE: slowfast/models/batchnorm_helper.py
  function get_norm (line 16) | def get_norm(cfg):
  class SubBatchNorm3d (line 40) | class SubBatchNorm3d(nn.Module):
    method __init__ (line 51) | def __init__(self, num_splits, **args):
    method _get_aggregated_mean_std (line 72) | def _get_aggregated_mean_std(self, means, stds, n):
    method aggregate_stats (line 87) | def aggregate_stats(self):
    method forward (line 101) | def forward(self, x):

FILE: slowfast/models/build.py
  function build_model (line 22) | def build_model(cfg, gpu_id=None):

FILE: slowfast/models/common.py
  class Mlp (line 7) | class Mlp(nn.Module):
    method __init__ (line 8) | def __init__(
    method forward (line 26) | def forward(self, x):
  class Permute (line 37) | class Permute(nn.Module):
    method __init__ (line 38) | def __init__(self, dims):
    method forward (line 42) | def forward(self, x):
  function drop_path (line 46) | def drop_path(x, drop_prob: float = 0.0, training: bool = False):
  class DropPath (line 62) | class DropPath(nn.Module):
    method __init__ (line 65) | def __init__(self, drop_prob=None):
    method forward (line 69) | def forward(self, x):
  class TwoStreamFusion (line 73) | class TwoStreamFusion(nn.Module):
    method __init__ (line 74) | def __init__(self, mode, dim=None, kernel=3, padding=1):
    method forward (line 141) | def forward(self, x):

FILE: slowfast/models/contrastive.py
  class ContrastiveModel (line 32) | class ContrastiveModel(nn.Module):
    method __init__ (line 37) | def __init__(self, cfg):
    method knn_mem_update (line 126) | def knn_mem_update(self, q_knn, index):
    method init_knn_labels (line 137) | def init_knn_labels(self, train_loader):
    method _update_history (line 153) | def _update_history(self):
    method _batch_shuffle (line 169) | def _batch_shuffle(self, x):
    method _batch_unshuffle (line 211) | def _batch_unshuffle(self, x, idx_restore):
    method eval_knn (line 227) | def eval_knn(self, q_knn, knn_k=200):
    method sim_loss (line 237) | def sim_loss(self, q, k):
    method momentum_anneal_cosine (line 246) | def momentum_anneal_cosine(self, epoch_exact):
    method _dequeue_and_enqueue (line 255) | def _dequeue_and_enqueue(self, keys, extra_keys=None):
    method batch_clips (line 284) | def batch_clips(self, clips):
    method compute_key_feat (line 296) | def compute_key_feat(
    method forward (line 358) | def forward(self, clips, index=None, time=None, epoch_exact=None, keys...
    method _simclr_precompute_pos_neg_mask_multi (line 758) | def _simclr_precompute_pos_neg_mask_multi(self):
    method run_swav_encoder_q (line 800) | def run_swav_encoder_q(self, im):
    method get_code (line 808) | def get_code(self, out):
    method run_swav_orig_encoder_q (line 817) | def run_swav_orig_encoder_q(self, x):
    method sinkhorn (line 825) | def sinkhorn(self, Q, iters):
    method distributed_sinkhorn (line 841) | def distributed_sinkhorn(self, Q, nmb_iters):
    method KLDivLoss (line 864) | def KLDivLoss(self, out, code):
  function l2_loss (line 871) | def l2_loss(x, y):
  class Normalize (line 875) | class Normalize(nn.Module):
    method __init__ (line 876) | def __init__(self, power=2, dim=1):
    method forward (line 881) | def forward(self, x):
  class Memory (line 887) | class Memory(nn.Module):
    method __init__ (line 888) | def __init__(self, length, duration, dim, cfg):
    method resize (line 903) | def resize(self, length, duration, dim):
    method get (line 916) | def get(self, ind, time, interp=False):
    method update (line 939) | def update(self, mem, momentum, ind, time, interp=False):
    method forward (line 986) | def forward(self, inputs):
  class Memory1D (line 990) | class Memory1D(nn.Module):
    method __init__ (line 991) | def __init__(self, length, duration, dim, cfg):
    method get (line 1005) | def get(self, ind, time, interp=False):
    method update (line 1017) | def update(self, mem, momentum, ind, time, interp=False):
  function contrastive_parameter_surgery (line 1031) | def contrastive_parameter_surgery(model, cfg, epoch_exact, cur_iter):
  function contrastive_forward (line 1058) | def contrastive_forward(model, cfg, inputs, index, time, epoch_exact, sc...

FILE: slowfast/models/head_helper.py
  class ResNetRoIHead (line 20) | class ResNetRoIHead(nn.Module):
    method __init__ (line 25) | def __init__(
    method forward (line 115) | def forward(self, inputs, bboxes):
  class MLPHead (line 147) | class MLPHead(nn.Module):
    method __init__ (line 148) | def __init__(
    method forward (line 189) | def forward(self, x):
  class ResNetBasicHead (line 198) | class ResNetBasicHead(nn.Module):
    method __init__ (line 207) | def __init__(
    method forward (line 305) | def forward(self, inputs):
  class X3DHead (line 353) | class X3DHead(nn.Module):
    method __init__ (line 362) | def __init__(
    method _construct_head (line 412) | def _construct_head(self, dim_in, dim_inner, dim_out, norm_module):
    method forward (line 461) | def forward(self, inputs):
  class TransformerBasicHead (line 491) | class TransformerBasicHead(nn.Module):
    method __init__ (line 496) | def __init__(
    method forward (line 547) | def forward(self, x):
  class MSSeparateHead (line 566) | class MSSeparateHead(nn.Module):
    method __init__ (line 576) | def __init__(
    method _init_weights (line 645) | def _init_weights(self, m):
    method forward (line 656) | def forward(self, block_outputs, output_masks, return_all, thw):

FILE: slowfast/models/losses.py
  class ContrastiveLoss (line 13) | class ContrastiveLoss(nn.Module):
    method __init__ (line 14) | def __init__(self, reduction="mean"):
    method forward (line 18) | def forward(self, inputs, dummy_labels=None):
  class MultipleMSELoss (line 24) | class MultipleMSELoss(nn.Module):
    method __init__ (line 29) | def __init__(self, reduction="mean"):
    method forward (line 38) | def forward(self, x, y):
  function get_loss_func (line 72) | def get_loss_func(loss_name):

FILE: slowfast/models/masked.py
  class MaskMViT (line 24) | class MaskMViT(MViT):
    method __init__ (line 25) | def __init__(self, cfg):
    method no_weight_decay (line 130) | def no_weight_decay(self):
    method fix_init_weight (line 149) | def fix_init_weight(self):
    method _get_multiscale_mask (line 165) | def _get_multiscale_mask(self, mask):
    method _patchify (line 178) | def _patchify(self, imgs, p=16, time_stride_loss=True):
    method _unpatchify (line 190) | def _unpatchify(self, x):
    method _get_pixel_label_2d (line 197) | def _get_pixel_label_2d(self, input_img, output_masks, norm=True):
    method _get_pixel_label_3d (line 212) | def _get_pixel_label_3d(
    method _get_hog_label_2d (line 232) | def _get_hog_label_2d(self, input_frames, output_masks):
    method _get_hog_label_3d (line 254) | def _get_hog_label_3d(self, input_frames, output_masks):
    method _mae_random_masking (line 283) | def _mae_random_masking(self, x, mask_ratio, mask_in=None):
    method _mae_forward_encoder (line 319) | def _mae_forward_encoder(self, x, mask_ratio, mask=None):
    method _mae_forward_decoder (line 394) | def _mae_forward_decoder(self, x, ids_restore, mask, thw):
    method _mae_forward (line 447) | def _mae_forward(self, imgs, mask_ratio=0.75, mask=None):
    method _mae_visualize (line 478) | def _mae_visualize(self, imgs, pred, mask):
    method _maskfeat_forward (line 519) | def _maskfeat_forward(self, x, mask, return_all=False):
    method forward (line 614) | def forward(self, x, return_all=False):

FILE: slowfast/models/nonlocal_helper.py
  class Nonlocal (line 10) | class Nonlocal(nn.Module):
    method __init__ (line 20) | def __init__(
    method _construct_nonlocal (line 65) | def _construct_nonlocal(
    method forward (line 103) | def forward(self, x):

FILE: slowfast/models/operators.py
  class SE (line 15) | class SE(nn.Module):
    method _round_width (line 18) | def _round_width(self, width, multiplier, min_width=8, divisor=8):
    method __init__ (line 37) | def __init__(self, dim_in, ratio, relu_act=True):
    method forward (line 55) | def forward(self, x):
  class HOGLayerC (line 62) | class HOGLayerC(nn.Module):
    method __init__ (line 63) | def __init__(self, nbins=9, pool=7, gaussian_window=0):
    method forward (line 80) | def forward(self, x):

FILE: slowfast/models/optimizer.py
  function construct_optimizer (line 10) | def construct_optimizer(model, cfg):
  function get_param_groups (line 146) | def get_param_groups(model, cfg):
  function get_epoch_lr (line 240) | def get_epoch_lr(cur_epoch, cfg):
  function set_lr (line 251) | def set_lr(optimizer, new_lr):
  class LARS (line 262) | class LARS:
    method __init__ (line 274) | def __init__(
    method __getstate__ (line 288) | def __getstate__(self):
    method __setstate__ (line 291) | def __setstate__(self, state):
    method state (line 295) | def state(self):
    method __repr__ (line 298) | def __repr__(self):
    method param_groups (line 302) | def param_groups(self):
    method param_groups (line 306) | def param_groups(self, value):
    method state_dict (line 309) | def state_dict(self):
    method load_state_dict (line 312) | def load_state_dict(self, state_dict):
    method zero_grad (line 315) | def zero_grad(self):
    method add_param_group (line 318) | def add_param_group(self, param_group):
    method step (line 321) | def step(self):
  function get_grad_norm_ (line 362) | def get_grad_norm_(parameters, norm_type=2.0):

FILE: slowfast/models/ptv_model_builder.py
  function get_head_act (line 29) | def get_head_act(act_func):
  class PTVResNet (line 50) | class PTVResNet(nn.Module):
    method __init__ (line 55) | def __init__(self, cfg):
    method _construct_network (line 79) | def _construct_network(self, cfg):
    method forward (line 198) | def forward(self, x, bboxes=None):
  class PTVSlowFast (line 214) | class PTVSlowFast(nn.Module):
    method __init__ (line 215) | def __init__(self, cfg):
    method _construct_network (line 234) | def _construct_network(self, cfg):
    method forward (line 390) | def forward(self, x, bboxes=None):
  class PTVX3D (line 405) | class PTVX3D(nn.Module):
    method __init__ (line 406) | def __init__(self, cfg):
    method _construct_network (line 427) | def _construct_network(self, cfg):
    method forward (line 483) | def forward(self, x, bboxes=None):
  class PTVCSN (line 496) | class PTVCSN(nn.Module):
    method __init__ (line 501) | def __init__(self, cfg):
    method _construct_network (line 518) | def _construct_network(self, cfg):
    method forward (line 568) | def forward(self, x, bboxes=None):
  class PTVR2plus1D (line 581) | class PTVR2plus1D(nn.Module):
    method __init__ (line 586) | def __init__(self, cfg):
    method _construct_network (line 603) | def _construct_network(self, cfg):
    method forward (line 669) | def forward(self, x, bboxes=None):
  class PTVMViT (line 682) | class PTVMViT(nn.Module):
    method __init__ (line 687) | def __init__(self, cfg):
    method _construct_network (line 704) | def _construct_network(self, cfg):
    method forward (line 748) | def forward(self, x, bboxes=None):

FILE: slowfast/models/resnet_helper.py
  function get_trans_func (line 12) | def get_trans_func(name):
  class BasicTransform (line 27) | class BasicTransform(nn.Module):
    method __init__ (line 32) | def __init__(
    method _construct (line 75) | def _construct(self, dim_in, dim_out, stride, dilation, norm_module):
    method forward (line 108) | def forward(self, x):
  class X3DTransform (line 118) | class X3DTransform(nn.Module):
    method __init__ (line 125) | def __init__(
    method _construct (line 188) | def _construct(
    method forward (line 253) | def forward(self, x):
  class BottleneckTransform (line 259) | class BottleneckTransform(nn.Module):
    method __init__ (line 265) | def __init__(
    method _construct (line 319) | def _construct(
    method forward (line 377) | def forward(self, x):
  class ResBlock (line 395) | class ResBlock(nn.Module):
    method __init__ (line 400) | def __init__(
    method _construct (line 468) | def _construct(
    method forward (line 512) | def forward(self, x):
  class ResStage (line 524) | class ResStage(nn.Module):
    method __init__ (line 535) | def __init__(
    method _construct (line 650) | def _construct(
    method forward (line 697) | def forward(self, inputs):

FILE: slowfast/models/reversible_mvit.py
  class ReversibleMViT (line 12) | class ReversibleMViT(nn.Module):
    method __init__ (line 24) | def __init__(self, config, model):
    method vanilla_backward (line 128) | def vanilla_backward(h, layers, buffer):
    method forward (line 141) | def forward(self, x):
  class RevBackProp (line 177) | class RevBackProp(Function):
    method forward (line 186) | def forward(
    method backward (line 221) | def backward(ctx, dx):
  class StageTransitionBlock (line 266) | class StageTransitionBlock(nn.Module):
    method __init__ (line 272) | def __init__(
    method forward (line 350) | def forward(
  class ReversibleBlock (line 412) | class ReversibleBlock(nn.Module):
    method __init__ (line 419) | def __init__(
    method seed_cuda (line 468) | def seed_cuda(self, key):
    method forward (line 491) | def forward(self, X_1, X_2):
    method backward_pass (line 528) | def backward_pass(
  class MLPSubblock (line 593) | class MLPSubblock(nn.Module):
    method __init__ (line 599) | def __init__(
    method forward (line 616) | def forward(self, x):
  class AttentionSubBlock (line 620) | class AttentionSubBlock(nn.Module):
    method __init__ (line 626) | def __init__(
    method forward (line 670) | def forward(self, x):

FILE: slowfast/models/stem_helper.py
  function get_stem_func (line 9) | def get_stem_func(name):
  class VideoModelStem (line 20) | class VideoModelStem(nn.Module):
    method __init__ (line 26) | def __init__(
    method _construct_stem (line 98) | def _construct_stem(self, dim_in, dim_out, norm_module, stem_func_name):
    method forward (line 115) | def forward(self, x):
  class ResNetBasicStem (line 127) | class ResNetBasicStem(nn.Module):
    method __init__ (line 134) | def __init__(
    method _construct_stem (line 181) | def _construct_stem(self, dim_in, dim_out, norm_module):
    method forward (line 196) | def forward(self, x):
  class X3DStem (line 204) | class X3DStem(nn.Module):
    method __init__ (line 211) | def __init__(
    method _construct_stem (line 258) | def _construct_stem(self, dim_in, dim_out, norm_module):
    method forward (line 280) | def forward(self, x):
  class PatchEmbed (line 288) | class PatchEmbed(nn.Module):
    method __init__ (line 293) | def __init__(
    method forward (line 315) | def forward(self, x, keep_spatial=False):

FILE: slowfast/models/utils.py
  function round_width (line 10) | def round_width(width, multiplier, min_width=1, divisor=1, verbose=False):
  function validate_checkpoint_wrapper_import (line 26) | def validate_checkpoint_wrapper_import(checkpoint_wrapper):
  function get_gkern (line 34) | def get_gkern(kernlen, std):
  function get_3d_sincos_pos_embed (line 55) | def get_3d_sincos_pos_embed(embed_dim, grid_size, t_size, cls_token=False):
  function get_2d_sincos_pos_embed (line 97) | def get_2d_sincos_pos_embed(embed_dim, grid_size, cls_token=False):
  function get_2d_sincos_pos_embed_from_grid (line 115) | def get_2d_sincos_pos_embed_from_grid(embed_dim, grid):
  function get_1d_sincos_pos_embed_from_grid (line 126) | def get_1d_sincos_pos_embed_from_grid(embed_dim, pos):
  function interpolate_pos_embed (line 152) | def interpolate_pos_embed(model, checkpoint_model):
  function calc_mvit_feature_geometry (line 185) | def calc_mvit_feature_geometry(cfg):

FILE: slowfast/models/video_model_builder.py
  class FuseFastToSlow (line 112) | class FuseFastToSlow(nn.Module):
    method __init__ (line 119) | def __init__(
    method forward (line 162) | def forward(self, x):
  class SlowFast (line 173) | class SlowFast(nn.Module):
    method __init__ (line 182) | def __init__(self, cfg):
    method _construct_network (line 203) | def _construct_network(self, cfg):
    method forward (line 423) | def forward(self, x, bboxes=None):
  class ResNet (line 445) | class ResNet(nn.Module):
    method __init__ (line 459) | def __init__(self, cfg):
    method _construct_network (line 480) | def _construct_network(self, cfg):
    method forward (line 645) | def forward(self, x, bboxes=None):
  class X3D (line 664) | class X3D(nn.Module):
    method __init__ (line 673) | def __init__(self, cfg):
    method _round_repeats (line 711) | def _round_repeats(self, repeats, multiplier):
    method _construct_network (line 718) | def _construct_network(self, cfg):
    method forward (line 799) | def forward(self, x, bboxes=None):
  class MViT (line 806) | class MViT(nn.Module):
    method __init__ (line 818) | def __init__(self, cfg):
    method _init_weights (line 1085) | def _init_weights(self, m):
    method no_weight_decay (line 1095) | def no_weight_decay(self):
    method _get_pos_embed (line 1118) | def _get_pos_embed(self, pos_embed, bcthw):
    method _forward_reversible (line 1143) | def _forward_reversible(self, x):
    method forward (line 1166) | def forward(self, x, bboxes=None, return_attn=False):

FILE: slowfast/utils/ava_eval_helper.py
  function make_image_key (line 45) | def make_image_key(video_id, timestamp):
  function read_csv (line 50) | def read_csv(csv_file, class_whitelist=None, load_score=False):
  function read_exclusions (line 87) | def read_exclusions(exclusions_file):
  function read_labelmap (line 105) | def read_labelmap(labelmap_file):
  function evaluate_ava_from_files (line 123) | def evaluate_ava_from_files(labelmap, groundtruth, detections, exclusions):
  function evaluate_ava (line 133) | def evaluate_ava(
  function run_evaluation (line 168) | def run_evaluation(categories, groundtruth, detections, excluded_keys, v...
  function get_ava_eval_data (line 235) | def get_ava_eval_data(
  function write_results (line 274) | def write_results(detections, filename):

FILE: slowfast/utils/benchmark.py
  function benchmark_data_loading (line 20) | def benchmark_data_loading(cfg):

FILE: slowfast/utils/bn_helper.py
  function compute_and_update_bn_stats (line 12) | def compute_and_update_bn_stats(model, data_loader, num_batches=200):

FILE: slowfast/utils/c2_model_loading.py
  function get_name_convert_func (line 9) | def get_name_convert_func():

FILE: slowfast/utils/checkpoint.py
  function make_checkpoint_dir (line 22) | def make_checkpoint_dir(path_to_job):
  function get_checkpoint_dir (line 38) | def get_checkpoint_dir(path_to_job):
  function get_path_to_checkpoint (line 47) | def get_path_to_checkpoint(path_to_job, epoch, task=""):
  function get_last_checkpoint (line 61) | def get_last_checkpoint(path_to_job, task):
  function has_checkpoint (line 81) | def has_checkpoint(path_to_job):
  function is_checkpoint_epoch (line 92) | def is_checkpoint_epoch(cfg, cur_epoch, multigrid_schedule=None):
  function save_checkpoint (line 113) | def save_checkpoint(path_to_job, model, optimizer, epoch, cfg, scaler=No...
  function inflate_weight (line 148) | def inflate_weight(state_dict_2d, state_dict_3d):
  function load_checkpoint (line 181) | def load_checkpoint(
  function sub_to_normal_bn (line 526) | def sub_to_normal_bn(sd):
  function c2_normal_to_sub_bn (line 567) | def c2_normal_to_sub_bn(key, model_keys):
  function normal_to_sub_bn (line 587) | def normal_to_sub_bn(checkpoint_sd, model_sd):
  function load_test_checkpoint (line 625) | def load_test_checkpoint(cfg, model):
  function load_train_checkpoint (line 663) | def load_train_checkpoint(cfg, model, optimizer, scaler=None):

FILE: slowfast/utils/distributed.py
  function init_distributed_training (line 22) | def init_distributed_training(cfg):
  function all_gather (line 26) | def all_gather(tensors):
  function all_reduce (line 46) | def all_reduce(tensors, average=True):
  function init_process_group (line 65) | def init_process_group(
  function is_master_proc (line 103) | def is_master_proc(num_gpus=8):
  function is_root_proc (line 113) | def is_root_proc():
  function get_rank (line 123) | def get_rank():
  function synchronize (line 134) | def synchronize():
  function _get_global_gloo_group (line 150) | def _get_global_gloo_group():
  function _serialize_to_tensor (line 163) | def _serialize_to_tensor(data, group):
  function _pad_to_largest_tensor (line 191) | def _pad_to_largest_tensor(tensor, group):
  function all_gather_unaligned (line 225) | def all_gather_unaligned(data, group=None):
  class GatherLayer (line 264) | class GatherLayer(torch.autograd.Function):
    method forward (line 268) | def forward(ctx, input):
    method backward (line 275) | def backward(ctx, *grads):
  class AllGatherWithGradient (line 282) | class AllGatherWithGradient(torch.autograd.Function):
    method forward (line 286) | def forward(ctx, input):
    method backward (line 294) | def backward(ctx, grad_output):

FILE: slowfast/utils/env.py
  function setup_environment (line 13) | def setup_environment():

FILE: slowfast/utils/logging.py
  function _suppress_print (line 19) | def _suppress_print():
  function _cached_log_stream (line 31) | def _cached_log_stream(filename):
  function setup_logging (line 38) | def setup_logging(output_dir=None):
  function get_logger (line 75) | def get_logger(name):
  function log_json_stats (line 85) | def log_json_stats(stats, output_dir=None):

FILE: slowfast/utils/lr_policy.py
  function get_lr_at_epoch (line 9) | def get_lr_at_epoch(cfg, cur_epoch):
  function lr_func_cosine (line 28) | def lr_func_cosine(cfg, cur_epoch):
  function lr_func_steps_with_relative_lrs (line 52) | def lr_func_steps_with_relative_lrs(cfg, cur_epoch):
  function get_step_index (line 65) | def get_step_index(cfg, cur_epoch):
  function get_lr_func (line 80) | def get_lr_func(lr_policy):

FILE: slowfast/utils/meters.py
  function get_ava_mini_groundtruth (line 28) | def get_ava_mini_groundtruth(full_groundtruth):
  class AVAMeter (line 46) | class AVAMeter:
    method __init__ (line 51) | def __init__(self, overall_iters, cfg, mode):
    method log_iter_stats (line 88) | def log_iter_stats(self, cur_epoch, cur_iter):
    method iter_tic (line 140) | def iter_tic(self):
    method iter_toc (line 147) | def iter_toc(self):
    method data_toc (line 154) | def data_toc(self):
    method reset (line 158) | def reset(self):
    method update_stats (line 168) | def update_stats(self, preds, ori_boxes, metadata, loss=None, lr=None):
    method finalize_metrics (line 187) | def finalize_metrics(self, log=True):
    method log_epoch_stats (line 220) | def log_epoch_stats(self, cur_epoch):
  class TestMeter (line 239) | class TestMeter:
    method __init__ (line 247) | def __init__(
    method reset (line 295) | def reset(self):
    method update_stats (line 305) | def update_stats(self, preds, labels, clip_ids):
    method log_iter_stats (line 338) | def log_iter_stats(self, cur_iter):
    method iter_tic (line 354) | def iter_tic(self):
    method iter_toc (line 361) | def iter_toc(self):
    method data_toc (line 368) | def data_toc(self):
    method finalize_metrics (line 372) | def finalize_metrics(self, ks=(1, 5)):
  class ScalarMeter (line 409) | class ScalarMeter:
    method __init__ (line 416) | def __init__(self, window_size):
    method reset (line 425) | def reset(self):
    method add_value (line 433) | def add_value(self, value):
    method get_win_median (line 441) | def get_win_median(self):
    method get_current_value (line 447) | def get_current_value(self):
    method get_win_avg (line 450) | def get_win_avg(self):
    method get_global_avg (line 456) | def get_global_avg(self):
  class ListMeter (line 463) | class ListMeter:
    method __init__ (line 464) | def __init__(self, list_size):
    method reset (line 473) | def reset(self):
    method add_value (line 481) | def add_value(self, value):
    method get_value (line 489) | def get_value(self):
    method get_global_avg (line 492) | def get_global_avg(self):
  class TrainMeter (line 499) | class TrainMeter:
    method __init__ (line 504) | def __init__(self, epoch_iters, cfg):
    method reset (line 530) | def reset(self):
    method iter_tic (line 546) | def iter_tic(self):
    method iter_toc (line 553) | def iter_toc(self):
    method data_toc (line 560) | def data_toc(self):
    method update_stats (line 564) | def update_stats(
    method log_iter_stats (line 608) | def log_iter_stats(self, cur_epoch, cur_iter):
    method log_epoch_stats (line 643) | def log_epoch_stats(self, cur_epoch):
  class ValMeter (line 679) | class ValMeter:
    method __init__ (line 684) | def __init__(self, max_iter, cfg):
    method reset (line 709) | def reset(self):
    method iter_tic (line 724) | def iter_tic(self):
    method iter_toc (line 731) | def iter_toc(self):
    method data_toc (line 738) | def data_toc(self):
    method update_stats (line 742) | def update_stats(self, top1_err, top5_err, mb_size):
    method update_predictions (line 756) | def update_predictions(self, preds, labels):
    method log_iter_stats (line 767) | def log_iter_stats(self, cur_epoch, cur_iter):
    method log_epoch_stats (line 791) | def log_epoch_stats(self, cur_epoch):
  function get_map (line 823) | def get_map(preds, labels):
  class EpochTimer (line 850) | class EpochTimer:
    method __init__ (line 855) | def __init__(self) -> None:
    method reset (line 860) | def reset(self) -> None:
    method epoch_tic (line 867) | def epoch_tic(self):
    method epoch_toc (line 873) | def epoch_toc(self):
    method last_epoch_time (line 880) | def last_epoch_time(self):
    method avg_epoch_time (line 888) | def avg_epoch_time(self):
    method median_epoch_time (line 896) | def median_epoch_time(self):

FILE: slowfast/utils/metrics.py
  function topks_correct (line 9) | def topks_correct(preds, labels, ks):
  function topk_errors (line 43) | def topk_errors(preds, labels, ks):
  function topk_accuracies (line 55) | def topk_accuracies(preds, labels, ks):

FILE: slowfast/utils/misc.py
  function check_nan_losses (line 27) | def check_nan_losses(loss):
  function params_count (line 37) | def params_count(model, ignore_bn=False):
  function gpu_mem_usage (line 54) | def gpu_mem_usage():
  function cpu_mem_usage (line 65) | def cpu_mem_usage():
  function _get_model_analysis_input (line 79) | def _get_model_analysis_input(cfg, use_train_input):
  function get_model_stats (line 138) | def get_model_stats(model, cfg, mode, use_train_input):
  function log_model_info (line 173) | def log_model_info(model, cfg, use_train_input=True):
  function is_eval_epoch (line 200) | def is_eval_epoch(cfg, cur_epoch, multigrid_schedule):
  function plot_input (line 222) | def plot_input(tensor, bboxes=(), texts=(), path="./tmp_vis.png"):
  function plot_input_normed (line 252) | def plot_input_normed(
  function convert_normalized_images (line 352) | def convert_normalized_images(tensor):
  function frozen_bn_stats (line 361) | def frozen_bn_stats(model):
  function aggregate_sub_bn_stats (line 372) | def aggregate_sub_bn_stats(module):
  function launch_job (line 390) | def launch_job(cfg, init_method, func, daemon=False):
  function get_class_names (line 421) | def get_class_names(path, parent_path=None, subset_path=None):

FILE: slowfast/utils/multigrid.py
  class MultigridSchedule (line 12) | class MultigridSchedule:
    method init_multigrid (line 17) | def init_multigrid(self, cfg):
    method update_long_cycle (line 58) | def update_long_cycle(self, cfg, cur_epoch):
    method get_long_cycle_schedule (line 110) | def get_long_cycle_schedule(self, cfg):
  function print_schedule (line 196) | def print_schedule(schedule):
  function get_current_long_cycle_shape (line 205) | def get_current_long_cycle_shape(schedule, epoch):

FILE: slowfast/utils/multiprocessing.py
  function run (line 9) | def run(

FILE: slowfast/utils/parser.py
  function parse_args (line 13) | def parse_args():
  function load_config (line 67) | def load_config(args, path_to_config=None):

FILE: slowfast/utils/weight_init_helper.py
  function init_weights (line 10) | def init_weights(

FILE: slowfast/visualization/async_predictor.py
  class AsycnActionPredictor (line 17) | class AsycnActionPredictor:
    class _Predictor (line 18) | class _Predictor(mp.Process):
      method __init__ (line 19) | def __init__(self, cfg, task_queue, result_queue, gpu_id=None):
      method run (line 41) | def run(self):
    method __init__ (line 54) | def __init__(self, cfg, result_queue=None):
    method put (line 78) | def put(self, task):
    method get (line 88) | def get(self):
    method __call__ (line 106) | def __call__(self, task):
    method shutdown (line 110) | def shutdown(self):
    method result_available (line 115) | def result_available(self):
    method default_buffer_size (line 122) | def default_buffer_size(self):
  class AsyncVis (line 126) | class AsyncVis:
    class _VisWorker (line 127) | class _VisWorker(mp.Process):
      method __init__ (line 128) | def __init__(self, video_vis, task_queue, result_queue):
      method run (line 141) | def run(self):
    method __init__ (line 154) | def __init__(self, video_vis, n_workers=None):
    method put (line 181) | def put(self, task):
    method get (line 191) | def get(self):
    method __call__ (line 211) | def __call__(self, task):
    method shutdown (line 218) | def shutdown(self):
    method result_available (line 223) | def result_available(self):
    method default_buffer_size (line 227) | def default_buffer_size(self):
  class _StopToken (line 231) | class _StopToken:
  class AsyncDemo (line 235) | class AsyncDemo:
    method __init__ (line 240) | def __init__(self, cfg, async_vis):
    method put (line 250) | def put(self, task):
    method get (line 260) | def get(self):
  function draw_predictions (line 272) | def draw_predictions(task, video_vis):

FILE: slowfast/visualization/ava_demo_precomputed_boxes.py
  class AVAVisualizerWithPrecomputedBox (line 24) | class AVAVisualizerWithPrecomputedBox:
    method __init__ (line 30) | def __init__(self, cfg):
    method get_output_file (line 77) | def get_output_file(self, path):
    method get_input_clip (line 91) | def get_input_clip(self, keyframe_idx):
    method get_predictions (line 122) | def get_predictions(self):
    method draw_video (line 187) | def draw_video(self):
    method __call__ (line 304) | def __call__(self):
    method display (line 308) | def display(self, frame):
    method _get_keyframe_clip (line 318) | def _get_keyframe_clip(self, keyframe_idx):
    method _get_frame_range (line 330) | def _get_frame_range(self, start_idx, num_frames):
  function merge_pred_gt_boxes (line 353) | def merge_pred_gt_boxes(pred_dict, gt_dict=None):
  function load_boxes_labels (line 381) | def load_boxes_labels(cfg, video_name, fps, img_width, img_height):

FILE: slowfast/visualization/demo_loader.py
  class VideoManager (line 17) | class VideoManager:
    method __init__ (line 22) | def __init__(self, cfg):
    method __iter__ (line 65) | def __iter__(self):
    method __next__ (line 68) | def __next__(self):
    method get_output_file (line 98) | def get_output_file(self, path, fps=30):
    method display (line 113) | def display(self, task):
    method clean (line 128) | def clean(self):
    method start (line 138) | def start(self):
    method join (line 141) | def join(self):
  class ThreadVideoManager (line 145) | class ThreadVideoManager:
    method __init__ (line 151) | def __init__(self, cfg):
    method get_output_file (line 207) | def get_output_file(self, path, fps=30):
    method __iter__ (line 222) | def __iter__(self):
    method put_fn (line 225) | def put_fn(self):
    method __next__ (line 262) | def __next__(self):
    method get_fn (line 289) | def get_fn(self):
    method display (line 319) | def display(self, task):
    method start (line 329) | def start(self):
    method join (line 344) | def join(self):
    method clean (line 347) | def clean(self):

FILE: slowfast/visualization/gradcam_utils.py
  class GradCAM (line 11) | class GradCAM:
    method __init__ (line 18) | def __init__(self, model, target_layers, data_mean, data_std, colormap...
    method _register_single_hook (line 42) | def _register_single_hook(self, layer_name):
    method _register_hooks (line 60) | def _register_hooks(self):
    method _calculate_localization_map (line 67) | def _calculate_localization_map(self, inputs, labels=None):
    method __call__ (line 133) | def __call__(self, inputs, labels=None, alpha=0.5):

FILE: slowfast/visualization/prediction_vis.py
  class WrongPredictionVis (line 15) | class WrongPredictionVis:
    method __init__ (line 21) | def __init__(self, cfg):
    method _pick_wrong_preds (line 45) | def _pick_wrong_preds(self, labels, preds):
    method visualize_vid (line 71) | def visualize_vid(self, video_input, labels, preds, batch_idx):
    method wrong_class_prediction (line 118) | def wrong_class_prediction(self):
    method clean (line 127) | def clean(self):

FILE: slowfast/visualization/predictor.py
  class Predictor (line 20) | class Predictor:
    method __init__ (line 25) | def __init__(self, cfg, gpu_id=None):
    method __call__ (line 47) | def __call__(self, task):
  class ActionPredictor (line 114) | class ActionPredictor:
    method __init__ (line 119) | def __init__(self, cfg, async_vis=None, gpu_id=None):
    method put (line 130) | def put(self, task):
    method get (line 141) | def get(self):
  class Detectron2Predictor (line 153) | class Detectron2Predictor:
    method __init__ (line 159) | def __init__(self, cfg, gpu_id=None):
    method __call__ (line 180) | def __call__(self, task):

FILE: slowfast/visualization/tensorboard_vis.py
  class TensorboardWriter (line 20) | class TensorboardWriter:
    method __init__ (line 25) | def __init__(self, cfg):
    method add_scalars (line 86) | def add_scalars(self, data_dict, global_step=None):
    method plot_eval (line 97) | def plot_eval(self, preds, labels, global_step=None):
    method add_video (line 167) | def add_video(self, vid_tensor, tag="Video Input", global_step=None, f...
    method plot_weights_and_activations (line 179) | def plot_weights_and_activations(
    method flush (line 223) | def flush(self):
    method close (line 226) | def close(self):
  function add_confusion_matrix (line 231) | def add_confusion_matrix(
  function plot_hist (line 276) | def plot_hist(
  function add_ndim_array (line 326) | def add_ndim_array(
  function add_heatmap (line 399) | def add_heatmap(tensor):

FILE: slowfast/visualization/utils.py
  function get_confusion_matrix (line 16) | def get_confusion_matrix(preds, labels, num_classes, normalize="true"):
  function plot_confusion_matrix (line 48) | def plot_confusion_matrix(cmtx, num_classes, class_names=None, figsize=N...
  function plot_topk_histogram (line 92) | def plot_topk_histogram(tag, array, k=10, class_names=None, figsize=None):
  class GetWeightAndActivation (line 158) | class GetWeightAndActivation:
    method __init__ (line 163) | def __init__(self, model, layers):
    method _get_layer (line 178) | def _get_layer(self, layer_name):
    method _register_single_hook (line 191) | def _register_single_hook(self, layer_name):
    method _register_hooks (line 204) | def _register_hooks(self):
    method get_activations (line 211) | def get_activations(self, input, bboxes=None):
    method get_weights (line 236) | def get_weights(self):
  function get_indexing (line 253) | def get_indexing(string):
  function process_layer_index_data (line 276) | def process_layer_index_data(layer_ls, layer_name_prefix=""):
  function process_cv2_inputs (line 302) | def process_cv2_inputs(frames, cfg):
  function get_layer (line 323) | def get_layer(model, layer_name):
  class TaskInfo (line 341) | class TaskInfo:
    method __init__ (line 342) | def __init__(self):
    method add_frames (line 353) | def add_frames(self, idx, frames):
    method add_bboxes (line 363) | def add_bboxes(self, bboxes):
    method add_action_preds (line 369) | def add_action_preds(self, preds):

FILE: slowfast/visualization/video_visualizer.py
  function _create_text_labels (line 18) | def _create_text_labels(classes, scores, class_names, ground_truth=False):
  class ImgVisualizer (line 43) | class ImgVisualizer(Visualizer):
    method __init__ (line 44) | def __init__(self, img_rgb, meta, **kwargs):
    method draw_text (line 59) | def draw_text(
    method draw_multiple_text (line 107) | def draw_multiple_text(
    method draw_multiple_text_upward (line 182) | def draw_multiple_text_upward(
    method draw_multiple_text_downward (line 235) | def draw_multiple_text_downward(
    method _align_x_coordinate (line 288) | def _align_x_coordinate(self, box_coordinate):
    method _align_y_top (line 310) | def _align_y_top(self, box_coordinate, num_text, textbox_width):
    method _align_y_bottom (line 328) | def _align_y_bottom(self, box_coordinate, num_text, textbox_width):
  class VideoVisualizer (line 347) | class VideoVisualizer:
    method __init__ (line 348) | def __init__(
    method _get_color (line 392) | def _get_color(self, class_id):
    method draw_one_frame (line 400) | def draw_one_frame(
    method draw_clip_range (line 508) | def draw_clip_range(
    method draw_clip (line 562) | def draw_clip(
    method _adjust_frames_type (line 629) | def _adjust_frames_type(self, frames):
    method _get_thres_array (line 651) | def _get_thres_array(self, common_class_names=None):

FILE: tools/benchmark.py
  function main (line 15) | def main():

FILE: tools/demo_net.py
  function run_demo (line 21) | def run_demo(cfg, frame_provider):
  function demo (line 94) | def demo(cfg):

FILE: tools/run_net.py
  function main (line 15) | def main():

FILE: tools/test_net.py
  function perform_test (line 25) | def perform_test(test_loader, model, test_meter, cfg, writer=None):
  function test (line 154) | def test(cfg):

FILE: tools/train_net.py
  function train_epoch (line 33) | def train_epoch(
  function eval_epoch (line 282) | def eval_epoch(val_loader, model, val_meter, cur_epoch, cfg, train_loade...
  function calculate_and_update_precise_bn (line 425) | def calculate_and_update_precise_bn(loader, model, num_iters=200, use_gp...
  function build_trainer (line 449) | def build_trainer(cfg):
  function train (line 493) | def train(cfg):

FILE: tools/visualization.py
  function run_visualization (line 29) | def run_visualization(vis_loader, model, cfg, writer=None):
  function perform_wrong_prediction_vis (line 183) | def perform_wrong_prediction_vis(vis_loader, model, cfg):
  function visualize (line 243) | def visualize(cfg):