


'''simple docstring'''

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 _SCREAMING_SNAKE_CASE				(A	)	->	Dict:






       """simple docstring"""







       lowercase__				      =			TimesformerConfig()

       if "large" in model_name:
              lowercase__				      =			96

       if "hr" in model_name:
              lowercase__				      =			16
              lowercase__				      =			448

       lowercase__				      =			'''huggingface/label-files'''
       if "k400" in model_name:
              lowercase__				      =			400
              lowercase__				      =			'''kinetics400-id2label.json'''
       elif "k600" in model_name:
              lowercase__				      =			600
              lowercase__				      =			'''kinetics600-id2label.json'''
       elif "ssv2" in model_name:
              lowercase__				      =			174
              lowercase__				      =			'''something-something-v2-id2label.json'''
       else:
              raise ValueError('''Model name should either contain \'k400\', \'k600\' or \'ssv2\'.'''	)
       lowercase__				      =			json.load(open(hf_hub_download(A  ,      A  ,      repo_type='''dataset'''	)  ,      '''r'''	)	)
       lowercase__				      =			{int(A	): v for k, v in idalabel.items()}
       lowercase__				      =			idalabel
       lowercase__				      =			{v: k for k, v in idalabel.items()}

       return config

def _SCREAMING_SNAKE_CASE				(A	)	->	Union[str, Any]:






       """simple docstring"""







       if "encoder." in name:
              lowercase__				      =			name.replace('''encoder.'''  ,      ''''''	)
       if "cls_token" in name:
              lowercase__				      =			name.replace('''cls_token'''  ,      '''timesformer.embeddings.cls_token'''	)
       if "pos_embed" in name:
              lowercase__				      =			name.replace('''pos_embed'''  ,      '''timesformer.embeddings.position_embeddings'''	)
       if "time_embed" in name:
              lowercase__				      =			name.replace('''time_embed'''  ,      '''timesformer.embeddings.time_embeddings'''	)
       if "patch_embed.proj" in name:
              lowercase__				      =			name.replace('''patch_embed.proj'''  ,      '''timesformer.embeddings.patch_embeddings.projection'''	)
       if "patch_embed.norm" in name:
              lowercase__				      =			name.replace('''patch_embed.norm'''  ,      '''timesformer.embeddings.norm'''	)
       if "blocks" in name:
              lowercase__				      =			name.replace('''blocks'''  ,      '''timesformer.encoder.layer'''	)
       if "attn.proj" in name:
              lowercase__				      =			name.replace('''attn.proj'''  ,      '''attention.output.dense'''	)
       if "attn" in name and "bias" not in name and "temporal" not in name:
              lowercase__				      =			name.replace('''attn'''  ,      '''attention.self'''	)
       if "attn" in name and "temporal" not in name:
              lowercase__				      =			name.replace('''attn'''  ,      '''attention.attention'''	)
       if "temporal_norm1" in name:
              lowercase__				      =			name.replace('''temporal_norm1'''  ,      '''temporal_layernorm'''	)
       if "temporal_attn.proj" in name:
              lowercase__				      =			name.replace('''temporal_attn'''  ,      '''temporal_attention.output.dense'''	)
       if "temporal_fc" in name:
              lowercase__				      =			name.replace('''temporal_fc'''  ,      '''temporal_dense'''	)
       if "norm1" in name and "temporal" not in name:
              lowercase__				      =			name.replace('''norm1'''  ,      '''layernorm_before'''	)
       if "norm2" in name:
              lowercase__				      =			name.replace('''norm2'''  ,      '''layernorm_after'''	)
       if "mlp.fc1" in name:
              lowercase__				      =			name.replace('''mlp.fc1'''  ,      '''intermediate.dense'''	)
       if "mlp.fc2" in name:
              lowercase__				      =			name.replace('''mlp.fc2'''  ,      '''output.dense'''	)
       if "norm.weight" in name and "fc" not in name and "temporal" not in name:
              lowercase__				      =			name.replace('''norm.weight'''  ,      '''timesformer.layernorm.weight'''	)
       if "norm.bias" in name and "fc" not in name and "temporal" not in name:
              lowercase__				      =			name.replace('''norm.bias'''  ,      '''timesformer.layernorm.bias'''	)
       if "head" in name:
              lowercase__				      =			name.replace('''head'''  ,      '''classifier'''	)

       return name

def _SCREAMING_SNAKE_CASE				(A  ,      A	)	->	Union[str, Any]:






       """simple docstring"""







       for key in orig_state_dict.copy().keys():
              lowercase__				      =			orig_state_dict.pop(A	)

              if key.startswith('''model.'''	):
                     lowercase__				      =			key.replace('''model.'''  ,      ''''''	)

              if "qkv" in key:
                     lowercase__				      =			key.split('''.'''	)
                     lowercase__				      =			int(key_split[1]	)
                     lowercase__				      =			'''timesformer.encoder.layer.'''
                     if "temporal" in key:
                            lowercase__				      =			'''.temporal_attention.attention.qkv.'''
                     else:
                            lowercase__				      =			'''.attention.attention.qkv.'''
                     if "weight" in key:
                            lowercase__				      =			val
                     else:
                            lowercase__				      =			val
              else:
                     lowercase__				      =			val

       return orig_state_dict

def _SCREAMING_SNAKE_CASE				()	->	str:






       """simple docstring"""







       lowercase__				      =			hf_hub_download(
           repo_id='''hf-internal-testing/spaghetti-video'''  ,      filename='''eating_spaghetti.npy'''  ,      repo_type='''dataset'''	)
       lowercase__				      =			np.load(A	)
       return list(A	)

def _SCREAMING_SNAKE_CASE				(A  ,      A  ,      A  ,      A	)	->	int:






       """simple docstring"""







       lowercase__				      =			get_timesformer_config(A	)

       lowercase__				      =			TimesformerForVideoClassification(A	)

       # download original checkpoint, hosted on Google Drive
       lowercase__				      =			'''pytorch_model.bin'''
       gdown.cached_download(A  ,      A  ,      quiet=A	)
       lowercase__				      =			torch.load(A  ,      map_location='''cpu'''	)
       if "model" in files:
              lowercase__				      =			files['''model''']
       elif "module" in files:
              lowercase__				      =			files['''module''']
       else:
              lowercase__				      =			files['''model_state''']
       lowercase__				      =			convert_state_dict(A  ,      A	)

       model.load_state_dict(A	)
       model.eval()

       # verify model on basic input
       lowercase__				      =			VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]  ,      image_std=[0.5, 0.5, 0.5]	)
       lowercase__				      =			prepare_video()
       lowercase__				      =			image_processor(video[:8]  ,      return_tensors='''pt'''	)

       lowercase__				      =			model(**A	)
       lowercase__				      =			outputs.logits

       lowercase__				      =			[
           # 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":
              lowercase__				      =			torch.Size([1, 400]	)
              lowercase__				      =			torch.tensor([-0.3_016, -0.7_713, -0.4_205]	)
       elif model_name == "timesformer-base-finetuned-k600":
              lowercase__				      =			torch.Size([1, 600]	)
              lowercase__				      =			torch.tensor([-0.7_267, -0.7_466, 3.2_404]	)
       elif model_name == "timesformer-base-finetuned-ssv2":
              lowercase__				      =			torch.Size([1, 174]	)
              lowercase__				      =			torch.tensor([-0.9_059, 0.6_433, -3.1_457]	)
       elif model_name == "timesformer-large-finetuned-k400":
              lowercase__				      =			torch.Size([1, 400]	)
              lowercase__				      =			torch.tensor([0, 0, 0]	)
       elif model_name == "timesformer-large-finetuned-k600":
              lowercase__				      =			torch.Size([1, 600]	)
              lowercase__				      =			torch.tensor([0, 0, 0]	)
       elif model_name == "timesformer-large-finetuned-ssv2":
              lowercase__				      =			torch.Size([1, 174]	)
              lowercase__				      =			torch.tensor([0, 0, 0]	)
       elif model_name == "timesformer-hr-finetuned-k400":
              lowercase__				      =			torch.Size([1, 400]	)
              lowercase__				      =			torch.tensor([-0.9_617, -3.7_311, -3.7_708]	)
       elif model_name == "timesformer-hr-finetuned-k600":
              lowercase__				      =			torch.Size([1, 600]	)
              lowercase__				      =			torch.tensor([2.5_273, 0.7_127, 1.8_848]	)
       elif model_name == "timesformer-hr-finetuned-ssv2":
              lowercase__				      =			torch.Size([1, 174]	)
              lowercase__				      =			torch.tensor([-3.6_756, -0.7_513, 0.7_180]	)
       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]  ,      A  ,      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(A	)
              model.save_pretrained(A	)

       if push_to_hub:
              print('''Pushing to the hub...'''	)
              model.push_to_hub(f"fcakyon/{model_name}"	)


if __name__ == "__main__":
 lowerCamelCase							:       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.'
 )

 lowerCamelCase							:       Tuple  						=     parser.parse_args()
 convert_timesformer_checkpoint(
     args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
 )








'''simple docstring'''

# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer
from .base import PipelineTool


lowerCamelCase							:       Any  						=     'Here is a text containing a lot of information: \'\'\'{text}\'\'\'.\n\nCan you answer this question about the text: \'{question}\''
class   __lowerCAmelCase						(lowercase_					):





      '''simple docstring'''






      lowerCAmelCase__ :					Dict   =							"""google/flan-t5-base"""
      lowerCAmelCase__ :					List[Any]   =							(
          """This is a tool that answers questions related to a text. It takes two arguments named `text`, which is the """
          """text where to find the answer, and `question`, which is the question, and returns the answer to the question."""
      )
      lowerCAmelCase__ :					Any   =							"""text_qa"""
      lowerCAmelCase__ :					Union[str, Any]   =							AutoTokenizer
      lowerCAmelCase__ :					Any   =							AutoModelForSeqaSeqLM

      lowerCAmelCase__ :					Any   =							["""text""", """text"""]
      lowerCAmelCase__ :					Optional[int]   =							["""text"""]



      def 				UpperCamelCase__		(self   :   Union[str, Any]       ,						UpperCamelCase   :   str       ,						UpperCamelCase   :   str			):

             '''simple docstring'''







             lowercase__				      =			QA_PROMPT.format(text=UpperCamelCase       ,						question=UpperCamelCase			)
             return self.pre_processor(UpperCamelCase       ,						return_tensors='''pt'''			)



      def 				UpperCamelCase__		(self   :   Dict       ,						UpperCamelCase   :   List[Any]			):

             '''simple docstring'''







             lowercase__				      =			self.model.generate(**UpperCamelCase			)

             lowercase__      ,lowercase__				      =			inputs['''input_ids'''].shape
             lowercase__				      =			output_ids.shape[0]

             return output_ids.reshape(UpperCamelCase       ,						out_b // in_b       ,						*output_ids.shape[1:]			)[0][0]






      def 				UpperCamelCase__		(self   :   Tuple       ,						UpperCamelCase   :   Optional[Any]			):

             '''simple docstring'''







             return self.pre_processor.decode(UpperCamelCase       ,						skip_special_tokens=UpperCamelCase       ,						clean_up_tokenization_spaces=UpperCamelCase			)




