

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		:      Tuple		)   ->   List[str]:

 """simple docstring"""






 __lowerCAmelCase:       List[str]            =				TimesformerConfig()

 if "large" in model_name:
  __lowerCAmelCase:       int            =				96

 if "hr" in model_name:
  __lowerCAmelCase:       Dict            =				16
  __lowerCAmelCase:       str            =				4_48

 __lowerCAmelCase:       List[Any]            =				'huggingface/label-files'
 if "k400" in model_name:
  __lowerCAmelCase:       str            =				4_00
  __lowerCAmelCase:       List[Any]            =				'kinetics400-id2label.json'
 elif "k600" in model_name:
  __lowerCAmelCase:       Optional[Any]            =				6_00
  __lowerCAmelCase:       Optional[int]            =				'kinetics600-id2label.json'
 elif "ssv2" in model_name:
  __lowerCAmelCase:       Optional[int]            =				1_74
  __lowerCAmelCase:       Optional[int]            =				'something-something-v2-id2label.json'
 else:
  raise ValueError('Model name should either contain \'k400\', \'k600\' or \'ssv2\'.'		)
 __lowerCAmelCase:       str            =				json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE   , SCREAMING_SNAKE_CASE   , repo_type='dataset'		)   , 'r'		)		)
 __lowerCAmelCase:       List[Any]            =				{int(SCREAMING_SNAKE_CASE		): v for k, v in idalabel.items()}
 __lowerCAmelCase:       Union[str, Any]            =				idalabel
 __lowerCAmelCase:       Union[str, Any]            =				{v: k for k, v in idalabel.items()}

 return config







def _a			(	SCREAMING_SNAKE_CASE		:      List[str]		)   ->   Optional[int]:

 """simple docstring"""






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

 return name







def _a			(	SCREAMING_SNAKE_CASE		:      Any   , SCREAMING_SNAKE_CASE		:      Optional[int]		)   ->   Dict:

 """simple docstring"""






 for key in orig_state_dict.copy().keys():
  __lowerCAmelCase:       int            =				orig_state_dict.pop(SCREAMING_SNAKE_CASE		)

  if key.startswith('model.'		):
   __lowerCAmelCase:       Optional[Any]            =				key.replace('model.'   , ''		)

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

 return orig_state_dict







def _a			(	)   ->   Dict:

 """simple docstring"""






 __lowerCAmelCase:       Union[str, Any]            =				hf_hub_download(
     repo_id='hf-internal-testing/spaghetti-video'   , filename='eating_spaghetti.npy'   , repo_type='dataset'		)
 __lowerCAmelCase:       Optional[int]            =				np.load(SCREAMING_SNAKE_CASE		)
 return list(SCREAMING_SNAKE_CASE		)







def _a			(	SCREAMING_SNAKE_CASE		:      Dict   , SCREAMING_SNAKE_CASE		:      int   , SCREAMING_SNAKE_CASE		:      str   , SCREAMING_SNAKE_CASE		:      Union[str, Any]		)   ->   Optional[int]:

 """simple docstring"""






 __lowerCAmelCase:       Dict            =				get_timesformer_config(SCREAMING_SNAKE_CASE		)

 __lowerCAmelCase:       int            =				TimesformerForVideoClassification(SCREAMING_SNAKE_CASE		)

 # download original checkpoint, hosted on Google Drive
 __lowerCAmelCase:       int            =				'pytorch_model.bin'
 gdown.cached_download(SCREAMING_SNAKE_CASE   , SCREAMING_SNAKE_CASE   , quiet=SCREAMING_SNAKE_CASE		)
 __lowerCAmelCase:       Union[str, Any]            =				torch.load(SCREAMING_SNAKE_CASE   , map_location='cpu'		)
 if "model" in files:
  __lowerCAmelCase:       List[str]            =				files['model']
 elif "module" in files:
  __lowerCAmelCase:       Optional[Any]            =				files['module']
 else:
  __lowerCAmelCase:       List[Any]            =				files['model_state']
 __lowerCAmelCase:       List[str]            =				convert_state_dict(SCREAMING_SNAKE_CASE   , SCREAMING_SNAKE_CASE		)

 model.load_state_dict(SCREAMING_SNAKE_CASE		)
 model.eval()

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

 __lowerCAmelCase:       int            =				model(**SCREAMING_SNAKE_CASE		)
 __lowerCAmelCase:       Union[str, Any]            =				outputs.logits

 __lowerCAmelCase:       Dict            =				[
     # 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":
  __lowerCAmelCase:       Union[str, Any]            =				torch.Size([1, 4_00]		)
  __lowerCAmelCase:       Union[str, 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":
  __lowerCAmelCase:       Optional[Any]            =				torch.Size([1, 6_00]		)
  __lowerCAmelCase:       Dict            =				torch.tensor([-0.7_2_6_7, -0.7_4_6_6, 3.2_4_0_4]		)
 elif model_name == "timesformer-base-finetuned-ssv2":
  __lowerCAmelCase:       Optional[Any]            =				torch.Size([1, 1_74]		)
  __lowerCAmelCase:       Optional[int]            =				torch.tensor([-0.9_0_5_9, 0.6_4_3_3, -3.1_4_5_7]		)
 elif model_name == "timesformer-large-finetuned-k400":
  __lowerCAmelCase:       Union[str, Any]            =				torch.Size([1, 4_00]		)
  __lowerCAmelCase:       Dict            =				torch.tensor([0, 0, 0]		)
 elif model_name == "timesformer-large-finetuned-k600":
  __lowerCAmelCase:       str            =				torch.Size([1, 6_00]		)
  __lowerCAmelCase:       Optional[int]            =				torch.tensor([0, 0, 0]		)
 elif model_name == "timesformer-large-finetuned-ssv2":
  __lowerCAmelCase:       str            =				torch.Size([1, 1_74]		)
  __lowerCAmelCase:       List[str]            =				torch.tensor([0, 0, 0]		)
 elif model_name == "timesformer-hr-finetuned-k400":
  __lowerCAmelCase:       List[Any]            =				torch.Size([1, 4_00]		)
  __lowerCAmelCase:       Dict            =				torch.tensor([-0.9_6_1_7, -3.7_3_1_1, -3.7_7_0_8]		)
 elif model_name == "timesformer-hr-finetuned-k600":
  __lowerCAmelCase:       Optional[Any]            =				torch.Size([1, 6_00]		)
  __lowerCAmelCase:       List[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":
  __lowerCAmelCase:       Optional[Any]            =				torch.Size([1, 1_74]		)
  __lowerCAmelCase:       Any            =				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__":
  _a			=       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.'''
  )

  _a			=       parser.parse_args()
  convert_timesformer_checkpoint(
      args.checkpoint_url, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub
  )









import inspect
import unittest

from transformers import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import MODEL_MAPPING, PoolFormerConfig, PoolFormerForImageClassification, PoolFormerModel
  from transformers.models.poolformer.modeling_poolformer import POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import PoolFormerImageProcessor






class 							A_			(		snake_case__ ):


     def   UpperCAmelCase  (							self      :		int )							->     Tuple:
      __lowerCAmelCase:       Optional[Any]            =				self.config_class(**self.inputs_dict )
      self.parent.assertTrue(hasattr(UpperCAmelCase      ,  'hidden_sizes' ) )
      self.parent.assertTrue(hasattr(UpperCAmelCase      ,  'num_encoder_blocks' ) )







class 							A_			:


     def __init__(							self      :		Optional[int]      ,  UpperCAmelCase      :		Any      ,  UpperCAmelCase      :		List[str]=1_3      ,  UpperCAmelCase      :		Optional[Any]=6_4      ,  UpperCAmelCase      :		Union[str, Any]=3      ,  UpperCAmelCase      :		Optional[Any]=4      ,  UpperCAmelCase      :		Any=[2, 2, 2, 2]      ,  UpperCAmelCase      :		Optional[Any]=[8, 4, 2, 1]      ,  UpperCAmelCase      :		str=[1_6, 3_2, 6_4, 1_2_8]      ,  UpperCAmelCase      :		str=[1, 4, 8, 1_6]      ,  UpperCAmelCase      :		Optional[Any]=False      ,  UpperCAmelCase      :		str=True      ,  UpperCAmelCase      :		Optional[int]="gelu"      ,  UpperCAmelCase      :		Union[str, Any]=0.1      ,  UpperCAmelCase      :		Optional[Any]=0.02      ,  UpperCAmelCase      :		List[Any]=3      ,  UpperCAmelCase      :		Optional[int]=None      ,  )							->     Any:
      __lowerCAmelCase:       List[str]            =				parent
      __lowerCAmelCase:       Union[str, Any]            =				batch_size
      __lowerCAmelCase:       Union[str, Any]            =				image_size
      __lowerCAmelCase:       str            =				num_channels
      __lowerCAmelCase:       Tuple            =				num_encoder_blocks
      __lowerCAmelCase:       Optional[int]            =				sr_ratios
      __lowerCAmelCase:       Union[str, Any]            =				depths
      __lowerCAmelCase:       int            =				hidden_sizes
      __lowerCAmelCase:       List[Any]            =				downsampling_rates
      __lowerCAmelCase:       List[Any]            =				is_training
      __lowerCAmelCase:       Union[str, Any]            =				use_labels
      __lowerCAmelCase:       Union[str, Any]            =				hidden_act
      __lowerCAmelCase:       Any            =				hidden_dropout_prob
      __lowerCAmelCase:       List[Any]            =				initializer_range
      __lowerCAmelCase:       Dict            =				num_labels
      __lowerCAmelCase:       List[Any]            =				scope


     def   UpperCAmelCase  (							self      :		Optional[int] )							->     List[str]:
      __lowerCAmelCase:       Dict            =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

      __lowerCAmelCase:       str            =				None
      if self.use_labels:
       __lowerCAmelCase:       int            =				ids_tensor([self.batch_size, self.image_size, self.image_size]      ,  self.num_labels )

      __lowerCAmelCase:       Dict            =				PoolFormerConfig(
          image_size=self.image_size      ,  num_channels=self.num_channels      ,  num_encoder_blocks=self.num_encoder_blocks      ,  depths=self.depths      ,  hidden_sizes=self.hidden_sizes      ,  hidden_act=self.hidden_act      ,  hidden_dropout_prob=self.hidden_dropout_prob      ,  initializer_range=self.initializer_range      ,  )

      return config, pixel_values, labels


     def   UpperCAmelCase  (							self      :		str      ,  UpperCAmelCase      :		Tuple      ,  UpperCAmelCase      :		int      ,  UpperCAmelCase      :		List[Any] )							->     str:
      __lowerCAmelCase:       Any            =				PoolFormerModel(config=UpperCAmelCase )
      model.to(UpperCAmelCase )
      model.eval()
      __lowerCAmelCase:       List[str]            =				model(UpperCAmelCase )
      __lowerCAmelCase:       Union[str, Any]            =				self.image_size // 32.0
      self.parent.assertEqual(
          result.last_hidden_state.shape      ,  (self.batch_size, self.hidden_sizes[-1], expected_height, expected_width) )


     def   UpperCAmelCase  (							self      :		Any )							->     int:
      __lowerCAmelCase:       List[str]            =				self.prepare_config_and_inputs()
      __lowerCAmelCase     ,							__lowerCAmelCase     ,							__lowerCAmelCase:       Union[str, Any]            =				config_and_inputs
      __lowerCAmelCase:       List[str]            =				{'pixel_values': pixel_values}
      return config, inputs_dict







@require_torch
class 							A_			(		snake_case__							,     snake_case__							,     unittest.TestCase ):
     _lowercase      :					Optional[Any]       =     (PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
     _lowercase      :					List[Any]       =     (
         {'feature-extraction': PoolFormerModel, 'image-classification': PoolFormerForImageClassification}
         if is_torch_available()
         else {}
     )

     _lowercase      :					Tuple       =     False
     _lowercase      :					Tuple       =     False
     _lowercase      :					List[Any]       =     False
     _lowercase      :					Any       =     False
     _lowercase      :					List[Any]       =     False


     def   UpperCAmelCase  (							self      :		str )							->     Any:
      __lowerCAmelCase:       int            =				PoolFormerModelTester(self )
      __lowerCAmelCase:       int            =				PoolFormerConfigTester(self      ,  config_class=UpperCAmelCase )


     def   UpperCAmelCase  (							self      :		Optional[Any] )							->     int:
      self.config_tester.run_common_tests()


     def   UpperCAmelCase  (							self      :		int )							->     int:
      __lowerCAmelCase:       Union[str, Any]            =				self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*UpperCAmelCase )


     @unittest.skip('PoolFormer does not use inputs_embeds' )
     def   UpperCAmelCase  (							self      :		Optional[int] )							->     Union[str, Any]:
      pass


     @unittest.skip('PoolFormer does not have get_input_embeddings method and get_output_embeddings methods' )
     def   UpperCAmelCase  (							self      :		int )							->     List[str]:
      pass


     def   UpperCAmelCase  (							self      :		List[str] )							->     List[str]:
      def check_hidden_states_output(UpperCAmelCase      :		List[str]      ,  UpperCAmelCase      :		int      ,  UpperCAmelCase      :		List[Any] ):
       __lowerCAmelCase:       Union[str, Any]            =				model_class(UpperCAmelCase )
       model.to(UpperCAmelCase )
       model.eval()

       with torch.no_grad():
        __lowerCAmelCase:       Dict            =				model(**self._prepare_for_class(UpperCAmelCase      ,  UpperCAmelCase ) )

       __lowerCAmelCase:       int            =				outputs.hidden_states

       __lowerCAmelCase:       Optional[int]            =				self.model_tester.num_encoder_blocks
       self.assertEqual(len(UpperCAmelCase )      ,  UpperCAmelCase )

       # verify the first hidden states (first block)
       self.assertListEqual(
           list(hidden_states[0].shape[-3:] )      ,  [
               self.model_tester.hidden_sizes[0],
               self.model_tester.image_size // 4,
               self.model_tester.image_size // 4,
           ]      ,  )

      __lowerCAmelCase     ,							__lowerCAmelCase:       Dict            =				self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       __lowerCAmelCase:       Optional[int]            =				True
       check_hidden_states_output(UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase )

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       __lowerCAmelCase:       Optional[Any]            =				True

       check_hidden_states_output(UpperCAmelCase      ,  UpperCAmelCase      ,  UpperCAmelCase )


     def   UpperCAmelCase  (							self      :		List[Any] )							->     Optional[int]:
      if not self.model_tester.is_training:
       return

      __lowerCAmelCase     ,							__lowerCAmelCase:       Union[str, Any]            =				self.model_tester.prepare_config_and_inputs_for_common()
      __lowerCAmelCase:       Optional[int]            =				True

      for model_class in self.all_model_classes:
       if model_class in get_values(UpperCAmelCase ):
        continue
       __lowerCAmelCase:       str            =				model_class(UpperCAmelCase )
       model.to(UpperCAmelCase )
       model.train()
       __lowerCAmelCase:       Any            =				self._prepare_for_class(UpperCAmelCase      ,  UpperCAmelCase      ,  return_labels=UpperCAmelCase )
       __lowerCAmelCase:       str            =				model(**UpperCAmelCase ).loss
       loss.backward()


     def   UpperCAmelCase  (							self      :		Dict )							->     Tuple:
      __lowerCAmelCase     ,							__lowerCAmelCase:       Union[str, Any]            =				self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
       __lowerCAmelCase:       Union[str, Any]            =				model_class(UpperCAmelCase )
       __lowerCAmelCase:       Dict            =				inspect.signature(model.forward )
       # signature.parameters is an OrderedDict => so arg_names order is deterministic
       __lowerCAmelCase:       List[str]            =				[*signature.parameters.keys()]

       __lowerCAmelCase:       List[Any]            =				['pixel_values']
       self.assertListEqual(arg_names[:1]      ,  UpperCAmelCase )


     @slow
     def   UpperCAmelCase  (							self      :		int )							->     str:
      for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       __lowerCAmelCase:       List[str]            =				PoolFormerModel.from_pretrained(UpperCAmelCase )
       self.assertIsNotNone(UpperCAmelCase )







def _a			(	)   ->   Any:

 """simple docstring"""






 __lowerCAmelCase:       Optional[Any]            =				Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'		)
 return image






@require_torch
class 							A_			(		unittest.TestCase ):


     @slow
     def   UpperCAmelCase  (							self      :		Optional[Any] )							->     int:
      __lowerCAmelCase:       Optional[int]            =				PoolFormerImageProcessor()
      __lowerCAmelCase:       Any            =				PoolFormerForImageClassification.from_pretrained('sail/poolformer_s12' ).to(UpperCAmelCase )

      __lowerCAmelCase:       int            =				image_processor(images=prepare_img()      ,  return_tensors='pt' ).to(UpperCAmelCase )

      # forward pass
      with torch.no_grad():
       __lowerCAmelCase:       List[Any]            =				model(**UpperCAmelCase )

      # verify the logits
      __lowerCAmelCase:       List[Any]            =				torch.Size((1, 1_0_0_0) )
      self.assertEqual(outputs.logits.shape      ,  UpperCAmelCase )

      __lowerCAmelCase:       Union[str, Any]            =				torch.tensor([-0.6113, 0.1685, -0.0492] ).to(UpperCAmelCase )
      self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,  UpperCAmelCase      ,  atol=1E-4 ) )





