code: 
  
  
  
  
  
  import argparse
  import json
  
  import gdown
  import numpy as np
  import torch
  from huggingface_hub import hf_hub_download
  
  from transformers import TimesformerConfig, TimesformerForVideoClassification, VideoMAEImageProcessor
  def   _A (	SCREAMING_SNAKE_CASE  :     List[Any]		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      int            =TimesformerConfig()
  
    if "large" in model_name:
      a__			:      Optional[int]            =96
  
    if "hr" in model_name:
      a__			:      Any            =16
      a__			:      Optional[Any]            =448
  
    a__			:      int            ="huggingface/label-files"
    if "k400" in model_name:
      a__			:      List[Any]            =400
      a__			:      int            ="kinetics400-id2label.json"
    elif "k600" in model_name:
      a__			:      Dict            =600
      a__			:      Optional[Any]            ="kinetics600-id2label.json"
    elif "ssv2" in model_name:
      a__			:      Dict            =174
      a__			:      Optional[Any]            ="something-something-v2-id2label.json"
    else:
      raise ValueError("Model name should either contain 'k400', 'k600' or 'ssv2'."		)
    a__			:      str            =json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , repo_type="dataset"		) , "r"		)		)
    a__			:      List[Any]            ={int(SCREAMING_SNAKE_CASE		): v for k, v in idalabel.items()}
    a__			:      List[Any]            =idalabel
    a__			:      Any            ={v: k for k, v in idalabel.items()}
  
    return config
  def   _A (	SCREAMING_SNAKE_CASE  :     Dict		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    if "encoder." in name:
      a__			:      List[Any]            =name.replace("encoder." , ""		)
    if "cls_token" in name:
      a__			:      str            =name.replace("cls_token" , "timesformer.embeddings.cls_token"		)
    if "pos_embed" in name:
      a__			:      Optional[Any]            =name.replace("pos_embed" , "timesformer.embeddings.position_embeddings"		)
    if "time_embed" in name:
      a__			:      int            =name.replace("time_embed" , "timesformer.embeddings.time_embeddings"		)
    if "patch_embed.proj" in name:
      a__			:      int            =name.replace("patch_embed.proj" , "timesformer.embeddings.patch_embeddings.projection"		)
    if "patch_embed.norm" in name:
      a__			:      List[str]            =name.replace("patch_embed.norm" , "timesformer.embeddings.norm"		)
    if "blocks" in name:
      a__			:      str            =name.replace("blocks" , "timesformer.encoder.layer"		)
    if "attn.proj" in name:
      a__			:      Optional[Any]            =name.replace("attn.proj" , "attention.output.dense"		)
    if "attn" in name and "bias" not in name and "temporal" not in name:
      a__			:      str            =name.replace("attn" , "attention.self"		)
    if "attn" in name and "temporal" not in name:
      a__			:      Any            =name.replace("attn" , "attention.attention"		)
    if "temporal_norm1" in name:
      a__			:      Optional[Any]            =name.replace("temporal_norm1" , "temporal_layernorm"		)
    if "temporal_attn.proj" in name:
      a__			:      Dict            =name.replace("temporal_attn" , "temporal_attention.output.dense"		)
    if "temporal_fc" in name:
      a__			:      Union[str, Any]            =name.replace("temporal_fc" , "temporal_dense"		)
    if "norm1" in name and "temporal" not in name:
      a__			:      Any            =name.replace("norm1" , "layernorm_before"		)
    if "norm2" in name:
      a__			:      int            =name.replace("norm2" , "layernorm_after"		)
    if "mlp.fc1" in name:
      a__			:      int            =name.replace("mlp.fc1" , "intermediate.dense"		)
    if "mlp.fc2" in name:
      a__			:      Optional[int]            =name.replace("mlp.fc2" , "output.dense"		)
    if "norm.weight" in name and "fc" not in name and "temporal" not in name:
      a__			:      List[str]            =name.replace("norm.weight" , "timesformer.layernorm.weight"		)
    if "norm.bias" in name and "fc" not in name and "temporal" not in name:
      a__			:      List[Any]            =name.replace("norm.bias" , "timesformer.layernorm.bias"		)
    if "head" in name:
      a__			:      List[Any]            =name.replace("head" , "classifier"		)
  
    return name
  def   _A (	SCREAMING_SNAKE_CASE  :     List[Any] , SCREAMING_SNAKE_CASE  :     Any		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    for key in orig_state_dict.copy().keys():
      a__			:      int            =orig_state_dict.pop(SCREAMING_SNAKE_CASE		)
  
      if key.startswith("model."		):
        a__			:      Optional[int]            =key.replace("model." , ""		)
  
      if "qkv" in key:
        a__			:      Tuple            =key.split("."		)
        a__			:      Optional[Any]            =int(key_split[1]		)
        a__			:      Tuple            ="timesformer.encoder.layer."
        if "temporal" in key:
          a__			:      str            =".temporal_attention.attention.qkv."
        else:
          a__			:      str            =".attention.attention.qkv."
        if "weight" in key:
          a__			:      str            =val
        else:
          a__			:      Dict            =val
      else:
        a__			:      int            =val
  
    return orig_state_dict
  def   _A (	):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      Dict            =hf_hub_download(
        repo_id="hf-internal-testing/spaghetti-video" , filename="eating_spaghetti.npy" , repo_type="dataset"		)
    a__			:      str            =np.load(SCREAMING_SNAKE_CASE		)
    return list(SCREAMING_SNAKE_CASE		)
  def   _A (	SCREAMING_SNAKE_CASE  :     Optional[Any] , SCREAMING_SNAKE_CASE  :     Dict , SCREAMING_SNAKE_CASE  :     Tuple , SCREAMING_SNAKE_CASE  :     Union[str, Any]		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      int            =get_timesformer_config(SCREAMING_SNAKE_CASE		)
  
    a__			:      Dict            =TimesformerForVideoClassification(SCREAMING_SNAKE_CASE		)
  
    # download original checkpoint, hosted on Google Drive
    a__			:      Dict            ="pytorch_model.bin"
    gdown.cached_download(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , quiet=SCREAMING_SNAKE_CASE		)
    a__			:      Tuple            =torch.load(SCREAMING_SNAKE_CASE , map_location="cpu"		)
    if "model" in files:
      a__			:      Optional[Any]            =files["model"]
    elif "module" in files:
      a__			:      Dict            =files["module"]
    else:
      a__			:      int            =files["model_state"]
    a__			:      List[Any]            =convert_state_dict(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)
  
    model.load_state_dict(SCREAMING_SNAKE_CASE		)
    model.eval()
  
    # verify model on basic input
    a__			:      Any            =VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5] , image_std=[0.5, 0.5, 0.5]		)
    a__			:      Optional[int]            =prepare_video()
    a__			:      Tuple            =image_processor(video[:8] , return_tensors="pt"		)
  
    a__			:      int            =model(**SCREAMING_SNAKE_CASE		)
    a__			:      Any            =outputs.logits
  
    a__			:      List[str]            =[
        # Kinetics-400 checkpoints (hr = high resolution input of 448px instead of 224px)
        "timesformer-base-finetuned-k400",
        "timesformer-large-finetuned-k400",
        "timesformer-hr-finetuned-k400",
        # Kinetics-600 checkpoints (hr = high resolution input of 448px instead of 224px)
        "timesformer-base-finetuned-k600",
        "timesformer-large-finetuned-k600",
        "timesformer-hr-finetuned-k600",
        # Something-Something-v2 checkpoints (hr = high resolution input of 448px instead of 224px)
        "timesformer-base-finetuned-ssv2",
        "timesformer-large-finetuned-ssv2",
        "timesformer-hr-finetuned-ssv2",
    ]
  
    # NOTE: logits were tested with image_mean and image_std equal to [0.5, 0.5, 0.5] and [0.5, 0.5, 0.5]
    if model_name == "timesformer-base-finetuned-k400":
      a__			:      str            =torch.Size([1, 400]		)
      a__			:      Optional[Any]            =torch.tensor([-0.3_0_1_6, -0.7_7_1_3, -0.4_2_0_5]		)
    elif model_name == "timesformer-base-finetuned-k600":
      a__			:      str            =torch.Size([1, 600]		)
      a__			:      str            =torch.tensor([-0.7_2_6_7, -0.7_4_6_6, 3.2_4_0_4]		)
    elif model_name == "timesformer-base-finetuned-ssv2":
      a__			:      int            =torch.Size([1, 174]		)
      a__			:      Optional[Any]            =torch.tensor([-0.9_0_5_9, 0.6_4_3_3, -3.1_4_5_7]		)
    elif model_name == "timesformer-large-finetuned-k400":
      a__			:      List[Any]            =torch.Size([1, 400]		)
      a__			:      Optional[int]            =torch.tensor([0, 0, 0]		)
    elif model_name == "timesformer-large-finetuned-k600":
      a__			:      List[str]            =torch.Size([1, 600]		)
      a__			:      Optional[Any]            =torch.tensor([0, 0, 0]		)
    elif model_name == "timesformer-large-finetuned-ssv2":
      a__			:      Union[str, Any]            =torch.Size([1, 174]		)
      a__			:      int            =torch.tensor([0, 0, 0]		)
    elif model_name == "timesformer-hr-finetuned-k400":
      a__			:      int            =torch.Size([1, 400]		)
      a__			:      str            =torch.tensor([-0.9_6_1_7, -3.7_3_1_1, -3.7_7_0_8]		)
    elif model_name == "timesformer-hr-finetuned-k600":
      a__			:      Optional[Any]            =torch.Size([1, 600]		)
      a__			:      Optional[Any]            =torch.tensor([2.5_2_7_3, 0.7_1_2_7, 1.8_8_4_8]		)
    elif model_name == "timesformer-hr-finetuned-ssv2":
      a__			:      Union[str, Any]            =torch.Size([1, 174]		)
      a__			:      str            =torch.tensor([-3.6_7_5_6, -0.7_5_1_3, 0.7_1_8_0]		)
    else:
      raise ValueError(f'''Model name not supported. Should be one of {model_names}'''		)
  
    # verify logits
    assert logits.shape == expected_shape
    assert torch.allclose(logits[0, :3] , SCREAMING_SNAKE_CASE , atol=1e-4		)
    print("Logits ok!"		)
  
    if pytorch_dump_folder_path is not None:
      print(f'''Saving model and image processor to {pytorch_dump_folder_path}'''		)
      image_processor.save_pretrained(SCREAMING_SNAKE_CASE		)
      model.save_pretrained(SCREAMING_SNAKE_CASE		)
  
    if push_to_hub:
      print("Pushing to the hub..."		)
      model.push_to_hub(f'''fcakyon/{model_name}'''		)
  
  
  if __name__ == "__main__":
       UpperCAmelCase			:			Optional[int]	  = argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           """--checkpoint_url""",
           default="""https://drive.google.com/u/1/uc?id=17yvuYp9L4mn-HpIcK5Zo6K3UoOy1kA5l&export=download""",
           type=str,
           help=(
               """URL of the original PyTorch checkpoint (on Google Drive) you'd like to convert. Should be a direct"""
               """ download link."""
           ),
       )
       parser.add_argument(
           """--pytorch_dump_folder_path""",
           default="""""",
           type=str,
           help="""Path to the output PyTorch model directory.""",
       )
       parser.add_argument("""--model_name""", default="""timesformer-base-finetuned-k400""", type=str, help="""Name of the model.""")
       parser.add_argument(
           """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub."""
       )
  
       UpperCAmelCase			:			Union[str, Any]	  = parser.parse_args()
       convert_timesformer_checkpoint(
           args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
       )
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  import csv
  import dataclasses
  import json
  from dataclasses import dataclass
  from typing import List, Optional, Union
  
  from ...utils import is_tf_available, is_torch_available, logging
  
  
  UpperCAmelCase			:			int	  = logging.get_logger(__name__)
  
  
  
  
  
  
  
  @dataclass
  class        __lowerCAmelCase :
        _lowercase       :      str
        _lowercase       :      str
        _lowercase       :      Optional[str]        =    None
        _lowercase       :      Optional[str]        =    None
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		List[str]:
  
  
  
          '''simple docstring'''
  
  
  
  
          return json.dumps(dataclasses.asdict(self							)	,   indent=2							) + "\n"
  
  
  
  
  
  
  
  @dataclass(frozen=UpperCamelCase__)
  class        __lowerCAmelCase :
        _lowercase       :      List[int]
        _lowercase       :      Optional[List[int]]        =    None
        _lowercase       :      Optional[List[int]]        =    None
        _lowercase       :      Optional[Union[int, float]]        =    None
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		Optional[int]:
  
  
  
          '''simple docstring'''
  
  
  
  
          return json.dumps(dataclasses.asdict(self							)							) + "\n"
  
  
  
  
  
  
  
  class        __lowerCAmelCase :
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		Union[str, Any]:
  
  
  
          '''simple docstring'''
  
  
  
  
          raise NotImplementedError()
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		str:
  
  
  
          '''simple docstring'''
  
  
  
  
          raise NotImplementedError()
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		List[Any]:
  
  
  
          '''simple docstring'''
  
  
  
  
          raise NotImplementedError()
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		Optional[int]:
  
  
  
          '''simple docstring'''
  
  
  
  
          raise NotImplementedError()
  
  
  
  
  
  
  
        def      _lowercase						(					self							)     ->		Any:
  
  
  
          '''simple docstring'''
  
  
  
  
          raise NotImplementedError()
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__							)     ->		Dict:
  
  
  
          '''simple docstring'''
  
  
  
  
          if len(self.get_labels()							) > 1:
            a__			:      Dict            =self.get_labels()[int(example.label							)]
          return example
  
  
  
  
  
  
  
        @classmethod
        def      _lowercase						(					cls	,   lowerCAmelCase__	,   lowerCAmelCase__=None							)     ->		Union[str, Any]:
  
  
  
          '''simple docstring'''
  
  
  
  
          with open(lowerCAmelCase__	,   "r"	,   encoding="utf-8-sig"							) as f:
            return list(csv.reader(lowerCAmelCase__	,   delimiter="\t"	,   quotechar=lowerCAmelCase__							)							)
  
  
  
  
  
  
  
  class        __lowerCAmelCase (					UpperCamelCase__):
  
  
  
  
  
  
  
        def __init__(					self	,   lowerCAmelCase__=None	,   lowerCAmelCase__=None	,   lowerCAmelCase__="classification"	,   lowerCAmelCase__=False							)     ->		Any:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Any            =[] if labels is None else labels
          a__			:      List[Any]            =[] if examples is None else examples
          a__			:      List[str]            =mode
          a__			:      Tuple            =verbose
  
  
  
  
  
  
  
        def __len__(					self							)     ->		Optional[int]:
  
  
  
          '''simple docstring'''
  
  
  
  
          return len(self.examples							)
  
  
  
  
  
  
  
        def __getitem__(					self	,   lowerCAmelCase__							)     ->		int:
  
  
  
          '''simple docstring'''
  
  
  
  
          if isinstance(lowerCAmelCase__	,   lowerCAmelCase__							):
            return SingleSentenceClassificationProcessor(labels=self.labels	,   examples=self.examples[idx]							)
          return self.examples[idx]
  
  
  
  
  
  
  
        @classmethod
        def      _lowercase						(					cls	,   lowerCAmelCase__	,   lowerCAmelCase__=""	,   lowerCAmelCase__=0	,   lowerCAmelCase__=1	,   lowerCAmelCase__=None	,   lowerCAmelCase__=False	,   **lowerCAmelCase__							)     ->		List[str]:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Tuple            =cls(**lowerCAmelCase__							)
          processor.add_examples_from_csv(
              lowerCAmelCase__	,   split_name=lowerCAmelCase__	,   column_label=lowerCAmelCase__	,   column_text=lowerCAmelCase__	,   column_id=lowerCAmelCase__	,   skip_first_row=lowerCAmelCase__	,   overwrite_labels=lowerCAmelCase__	,   overwrite_examples=lowerCAmelCase__	,   )
          return processor
  
  
  
  
  
  
  
        @classmethod
        def      _lowercase						(					cls	,   lowerCAmelCase__	,   lowerCAmelCase__=None	,   **lowerCAmelCase__							)     ->		int:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      List[str]            =cls(**lowerCAmelCase__							)
          processor.add_examples(lowerCAmelCase__	,   labels=lowerCAmelCase__							)
          return processor
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__=""	,   lowerCAmelCase__=0	,   lowerCAmelCase__=1	,   lowerCAmelCase__=None	,   lowerCAmelCase__=False	,   lowerCAmelCase__=False	,   lowerCAmelCase__=False	,   )     ->		Dict:
  
  
  
          '''simple docstring'''
  
  
  
  
          a__			:      Dict            =self._read_tsv(lowerCAmelCase__							)
          if skip_first_row:
            a__			:      Tuple            =lines[1:]
          a__			:      List[Any]            =[]
          a__			:      int            =[]
          a__			:      str            =[]
          for i, line in enumerate(lowerCAmelCase__							):
            texts.append(line[column_text]							)
            labels.append(line[column_label]							)
            if column_id is not None:
              ids.append(line[column_id]							)
            else:
              a__			:      List[str]            =F'''{split_name}-{i}''' if split_name else str(lowerCAmelCase__							)
              ids.append(lowerCAmelCase__							)
  
          return self.add_examples(
              lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__	,   overwrite_labels=lowerCAmelCase__	,   overwrite_examples=lowerCAmelCase__							)
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__=None	,   lowerCAmelCase__=None	,   lowerCAmelCase__=False	,   lowerCAmelCase__=False							)     ->		List[Any]:
  
  
  
          '''simple docstring'''
  
  
  
  
          if labels is not None and len(lowerCAmelCase__							) != len(lowerCAmelCase__							):
            raise ValueError(
                F'''Text and labels have mismatched lengths {len(lowerCAmelCase__							)} and {len(lowerCAmelCase__							)}'''							)
          if ids is not None and len(lowerCAmelCase__							) != len(lowerCAmelCase__							):
            raise ValueError(F'''Text and ids have mismatched lengths {len(lowerCAmelCase__							)} and {len(lowerCAmelCase__							)}'''							)
          if ids is None:
            a__			:      Dict            =[None] * len(lowerCAmelCase__							)
          if labels is None:
            a__			:      str            =[None] * len(lowerCAmelCase__							)
          a__			:      Union[str, Any]            =[]
          a__			:      Optional[Any]            =set()
          for text_or_text_and_label, label, guid in zip(lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__							):
            if isinstance(lowerCAmelCase__	,   (tuple, list)							) and label is None:
              a__      ,							a__			:      int            =text_or_text_and_label
            else:
              a__			:      List[str]            =text_or_text_and_label
            added_labels.add(lowerCAmelCase__							)
            examples.append(InputExample(guid=lowerCAmelCase__	,   text_a=lowerCAmelCase__	,   text_b=lowerCAmelCase__	,   label=lowerCAmelCase__							)							)
  
          # Update examples
          if overwrite_examples:
            a__			:      Dict            =examples
          else:
            self.examples.extend(lowerCAmelCase__							)
  
          # Update labels
          if overwrite_labels:
            a__			:      Any            =list(lowerCAmelCase__							)
          else:
            a__			:      List[Any]            =list(set(self.labels							).union(lowerCAmelCase__							)							)
  
          return self.examples
  
  
  
  
  
  
  
        def      _lowercase						(					self	,   lowerCAmelCase__	,   lowerCAmelCase__=None	,   lowerCAmelCase__=False	,   lowerCAmelCase__=0	,   lowerCAmelCase__=True	,   lowerCAmelCase__=None	,   )     ->		int:
  
  
  
          '''simple docstring'''
  
  
  
  
          if max_length is None:
            a__			:      int            =tokenizer.max_len
  
          a__			:      int            ={label: i for i, label in enumerate(self.labels							)}
  
          a__			:      Union[str, Any]            =[]
          for ex_index, example in enumerate(self.examples							):
            if ex_index % 1_0_0_0_0 == 0:
              logger.info(F'''Tokenizing example {ex_index}'''							)
  
            a__			:      Dict            =tokenizer.encode(
                example.text_a	,   add_special_tokens=lowerCAmelCase__	,   max_length=min(lowerCAmelCase__	,   tokenizer.max_len							)	,   )
            all_input_ids.append(lowerCAmelCase__							)
  
          a__			:      List[Any]            =max(len(lowerCAmelCase__							) for input_ids in all_input_ids							)
  
          a__			:      Dict            =[]
          for ex_index, (input_ids, example) in enumerate(zip(lowerCAmelCase__	,   self.examples							)							):
            if ex_index % 1_0_0_0_0 == 0:
              logger.info(F'''Writing example {ex_index}/{len(self.examples							)}'''							)
            # The mask has 1 for real tokens and 0 for padding tokens. Only real
            # tokens are attended to.
            a__			:      Optional[Any]            =[1 if mask_padding_with_zero else 0] * len(lowerCAmelCase__							)
  
            # Zero-pad up to the sequence length.
            a__			:      List[str]            =batch_length - len(lowerCAmelCase__							)
            if pad_on_left:
              a__			:      Tuple            =([pad_token] * padding_length) + input_ids
              a__			:      Dict            =([0 if mask_padding_with_zero else 1] * padding_length) + attention_mask
            else:
              a__			:      List[str]            =input_ids + ([pad_token] * padding_length)
              a__			:      Any            =attention_mask + ([0 if mask_padding_with_zero else 1] * padding_length)
  
            if len(lowerCAmelCase__							) != batch_length:
              raise ValueError(F'''Error with input length {len(lowerCAmelCase__							)} vs {batch_length}'''							)
            if len(lowerCAmelCase__							) != batch_length:
              raise ValueError(F'''Error with input length {len(lowerCAmelCase__							)} vs {batch_length}'''							)
  
            if self.mode == "classification":
              a__			:      Dict            =label_map[example.label]
            elif self.mode == "regression":
              a__			:      Any            =float(example.label							)
            else:
              raise ValueError(self.mode							)
  
            if ex_index < 5 and self.verbose:
              logger.info("*** Example ***"							)
              logger.info(F'''guid: {example.guid}'''							)
              logger.info(F'''input_ids: {" ".join([str(lowerCAmelCase__							) for x in input_ids]							)}'''							)
              logger.info(F'''attention_mask: {" ".join([str(lowerCAmelCase__							) for x in attention_mask]							)}'''							)
              logger.info(F'''label: {example.label} (id = {label})'''							)
  
            features.append(InputFeatures(input_ids=lowerCAmelCase__	,   attention_mask=lowerCAmelCase__	,   label=lowerCAmelCase__							)							)
  
          if return_tensors is None:
            return features
          elif return_tensors == "tf":
            if not is_tf_available():
              raise RuntimeError("return_tensors set to 'tf' but TensorFlow 2.0 can't be imported"							)
            import tensorflow as tf
  
            def gen():
              for ex in features:
                yield ({"input_ids": ex.input_ids, "attention_mask": ex.attention_mask}, ex.label)
  
            a__			:      Any            =tf.data.Dataset.from_generator(
                lowerCAmelCase__	,   ({"input_ids": tf.intaa, "attention_mask": tf.intaa}, tf.intaa)	,   ({"input_ids": tf.TensorShape([None]							), "attention_mask": tf.TensorShape([None]							)}, tf.TensorShape([]							))	,   )
            return dataset
          elif return_tensors == "pt":
            if not is_torch_available():
              raise RuntimeError("return_tensors set to 'pt' but PyTorch can't be imported"							)
            import torch
            from torch.utils.data import TensorDataset
  
            a__			:      str            =torch.tensor([f.input_ids for f in features]	,   dtype=torch.long							)
            a__			:      str            =torch.tensor([f.attention_mask for f in features]	,   dtype=torch.long							)
            if self.mode == "classification":
              a__			:      Dict            =torch.tensor([f.label for f in features]	,   dtype=torch.long							)
            elif self.mode == "regression":
              a__			:      Tuple            =torch.tensor([f.label for f in features]	,   dtype=torch.float							)
  
            a__			:      List[str]            =TensorDataset(lowerCAmelCase__	,   lowerCAmelCase__	,   lowerCAmelCase__							)
            return dataset
          else:
            raise ValueError("return_tensors should be one of 'tf' or 'pt'"							)
  
  
  
  
  
  
  