class_docstr: Action forecasting 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.
class_docstr_tok: ["Action","forecasting","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.Random,
      dataset_type: VideoDatasetType = VideoDatasetType.Frame,
      seconds_per_clip: float = 2.0,
      clip_time_stride: float = 10.0,
      num_input_clips: int = 1,
      frames_per_clip: Optional[int] = None,
      num_forecast_actions: int = 1,
      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 subclip in seconds.
  
              clip_time_stride (float): The time difference in seconds between the start of
                  each input subclip.
  
              num_input_clips (int): The number of subclips to be included in the input
                  video data.
  
              frames_per_clip (Optional[int]): The number of frames per clip to sample.
                  If None, all frames in the clip will be included.
  
              num_forecast_actions (int): The number of actions to be included in the
                  action vector.
  
              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 = (
          EpicKitchenForecasting._define_clip_structure_generator(
              clip_sampling,
              seconds_per_clip,
              clip_time_stride,
              num_input_clips,
              num_forecast_actions,
          )
      )
      frame_filter = (
          EpicKitchenForecasting._frame_filter_generator(
              frames_per_clip,
              seconds_per_clip,
              clip_time_stride,
              num_input_clips,
          )
          if frames_per_clip is not None
          else None
      )
      transform = EpicKitchenForecasting._transform_generator(
          transform,
          num_forecast_actions,
          frames_per_clip,
          num_input_clips,
      )
  
      super().__init__(
          video_info_file_path=video_info_file_path,
          actions_file_path=actions_file_path,
          video_data_manifest_file_path=video_data_manifest_file_path,
          dataset_type=dataset_type,
          transform=transform,
          frame_filter=frame_filter,
          clip_sampler=define_clip_structure_fn,
          multithreaded_io=multithreaded_io,
      )
  
file_path: pytorchvideo/pytorchvideo/data/epic_kitchen_forecasting.py
imports: 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 EpicKitchenForecasting object from inherited base classes: EpicKitchenDataset with example: obj = EpicKitchenForecasting(video_info_file_path, actions_file_path, video_data_manifest_file_path, clip_sampling, dataset_type, seconds_per_clip, clip_time_stride, num_input_clips, frames_per_clip, num_forecast_actions, transform, multithreaded_io)