class_docstr: Action recognition video data set for EpicKitchen-55 Dataset.
  <https://epic-kitchens.github.io/2019/>
  
  This dataset handles the loading, decoding, and clip sampling for the videos.
code: def __init__(
      self,
      video_info_file_path: str,
      actions_file_path: str,
      video_data_manifest_file_path: str,
      clip_sampling: ClipSampling = ClipSampling.RandomOffsetUniform,
      dataset_type: VideoDatasetType = VideoDatasetType.Frame,
      seconds_per_clip: float = 2.0,
      frames_per_clip: Optional[int] = None,
      transform: Callable[[Dict[str, Any]], Any] = None,
      multithreaded_io: bool = True,
  ):
      f"""
          Args:
              video_info_file_path (str):
                  Path or URI to manifest with basic metadata of each video.
                  File must be a csv (w/header) with columns:
                  {[f.name for f in dataclass_fields(VideoInfo)]}
  
              actions_file_path (str):
                  Path or URI to manifest with action annotations for each video.
                  File must ber a csv (w/header) with columns:
                  {[f.name for f in dataclass_fields(ActionData)]}
  
              video_data_manifest_file_path (str):
                  The path to a json file outlining the available video data for the
                  associated videos. File must be a csv (w/header) with columns either:
  
                  For Frame Videos:
                  {[f.name for f in dataclass_fields(VideoFrameInfo)]}
  
                  For Encoded Videos:
                  {[f.name for f in dataclass_fields(EncodedVideoInfo)]}
  
                  To generate this file from a directory of video frames, see helper
                  functions in Module: pytorchvideo.data.epic_kitchen.utils
  
              clip_sampling (ClipSampling):
                  The type of sampling to perform to perform on the videos of the dataset.
  
              dataset_type (VideoDatasetType): The dataformat in which dataset
                  video data is store (e.g. video frames, encoded video etc).
  
              seconds_per_clip (float): The length of each sampled clip in seconds.
  
              frames_per_clip (Optional[int]): The number of frames per clip to sample.
  
              transform (Callable[[Dict[str, Any]], Any]):
                  This callable is evaluated on the clip output before the clip is returned.
                  It can be used for user-defined preprocessing and augmentations to the clips.
                  The clip input is a dictionary with the following format:
                      {{
                          'video_id': <str>,
                          'video': <video_tensor>,
                          'audio': <audio_tensor>,
                          'label': <List[ActionData]>,
                          'start_time': <float>,
                          'stop_time': <float>
                      }}
  
                  If transform is None, the raw clip output in the above format is
                      returned unmodified.
  
              multithreaded_io (bool):
                  Boolean to control whether parllelizable io operations are performed across
                  multiple threads.
          """
      define_clip_structure_fn = (
          EpicKitchenRecognition._define_clip_structure_generator(
              seconds_per_clip, clip_sampling
          )
      )
      transform = EpicKitchenRecognition._transform_generator(transform)
      frame_filter = (
          EpicKitchenRecognition._frame_filter_generator(
              frames_per_clip
          )
          if frames_per_clip is not None
          else None
      )
  
      super().__init__(
          video_info_file_path=video_info_file_path,
          actions_file_path=actions_file_path,
          dataset_type=dataset_type,
          video_data_manifest_file_path=video_data_manifest_file_path,
          transform=transform,
          frame_filter=frame_filter,
          clip_sampler=define_clip_structure_fn,
          multithreaded_io=multithreaded_io,
      )
  
file_path: pytorchvideo/pytorchvideo/data/epic_kitchen_recognition.py
imports: import random
  from dataclasses import fields
  from enum import Enum
  from typing import Any, Callable, Dict, List, Optional
  import torch
  from pytorchvideo.data.dataset_manifest_utils import EncodedVideoInfo, VideoClipInfo, VideoDatasetType, VideoFrameInfo, VideoInfo
  from pytorchvideo.data.epic_kitchen import ActionData, EpicKitchenDataset
  from pytorchvideo.data.video import Video
label_desc: Use image node_id 1 to create a new EpicKitchenRecognition object from inherited base classes: EpicKitchenDataset with example: obj = EpicKitchenRecognition(video_info_file_path, actions_file_path, video_data_manifest_file_path, clip_sampling, dataset_type, seconds_per_clip, frames_per_clip, transform, multithreaded_io)