



"""simple docstring"""
import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import TimesformerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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 torch import nn

       from transformers import (
           MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
           TimesformerForVideoClassification,
           TimesformerModel,
       )
       from transformers.models.timesformer.modeling_timesformer import TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       from transformers import VideoMAEImageProcessor


class    SCREAMING_SNAKE_CASE__ :

    def __init__(				self			:				str ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				str=1_3 ,  lowerCAmelCase_			:				Union[str, Any]=1_0 ,  lowerCAmelCase_			:				Optional[Any]=3 ,  lowerCAmelCase_			:				List[str]=2 ,  lowerCAmelCase_			:				int=2 ,  lowerCAmelCase_			:				List[Any]=True ,  lowerCAmelCase_			:				Dict=True ,  lowerCAmelCase_			:				List[str]=3_2 ,  lowerCAmelCase_			:				Optional[Any]=5 ,  lowerCAmelCase_			:				Union[str, Any]=4 ,  lowerCAmelCase_			:				Tuple=3_7 ,  lowerCAmelCase_			:				Any="gelu" ,  lowerCAmelCase_			:				Tuple=0.1 ,  lowerCAmelCase_			:				str=0.1 ,  lowerCAmelCase_			:				Optional[int]=1_0 ,  lowerCAmelCase_			:				str=0.02 ,  lowerCAmelCase_			:				Optional[Any]="divided_space_time" ,  lowerCAmelCase_			:				str=None ,  ):







      """simple docstring"""







      lowercase_								= parent
      lowercase_								= batch_size
      lowercase_								= image_size
      lowercase_								= num_channels
      lowercase_								= patch_size
      lowercase_								= num_frames
      lowercase_								= is_training
      lowercase_								= use_labels
      lowercase_								= hidden_size
      lowercase_								= num_hidden_layers
      lowercase_								= num_attention_heads
      lowercase_								= intermediate_size
      lowercase_								= hidden_act
      lowercase_								= hidden_dropout_prob
      lowercase_								= attention_probs_dropout_prob
      lowercase_								= attention_type
      lowercase_								= initializer_range
      lowercase_								= scope
      lowercase_								= num_labels

      # in TimeSformer, the number of spatial tokens equals num_frames * num_patches per frame + 1 CLS token
      lowercase_								= (image_size // patch_size) ** 2
      lowercase_								= (num_frames) * self.num_patches_per_frame + 1

    def 					_UpperCAmelCase	(				self			:				Tuple):







      """simple docstring"""







      lowercase_								= floats_tensor(
          [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size])

      lowercase_								= None
      if self.use_labels:
        lowercase_								= ids_tensor([self.batch_size] ,  self.num_labels)

      lowercase_								= self.get_config()

      return config, pixel_values, labels

    def 					_UpperCAmelCase	(				self			:				List[str]):







      """simple docstring"""







      lowercase_								= TimesformerConfig(
          image_size=self.image_size ,  patch_size=self.patch_size ,  num_channels=self.num_channels ,  num_frames=self.num_frames ,  hidden_size=self.hidden_size ,  num_hidden_layers=self.num_hidden_layers ,  num_attention_heads=self.num_attention_heads ,  intermediate_size=self.intermediate_size ,  hidden_act=self.hidden_act ,  hidden_dropout_prob=self.hidden_dropout_prob ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob ,  initializer_range=self.initializer_range ,  attention_type=self.attention_type ,  )
      lowercase_								= self.num_labels
      return config

    def 					_UpperCAmelCase	(				self			:				Optional[int] ,  lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				str):







      """simple docstring"""







      lowercase_								= TimesformerModel(config=lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()
      lowercase_								= model(lowerCAmelCase_)
      self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, self.seq_length, self.hidden_size))

    def 					_UpperCAmelCase	(				self			:				List[str] ,  lowerCAmelCase_			:				Tuple ,  lowerCAmelCase_			:				int ,  lowerCAmelCase_			:				Any):







      """simple docstring"""







      lowercase_								= TimesformerForVideoClassification(lowerCAmelCase_)
      model.to(lowerCAmelCase_)
      model.eval()

      lowercase_								= model(lowerCAmelCase_)

      # verify the logits shape
      lowercase_								= torch.Size((self.batch_size, self.num_labels))
      self.parent.assertEqual(result.logits.shape ,  lowerCAmelCase_)




    def 					_UpperCAmelCase	(				self			:				Optional[int]):







      """simple docstring"""







      lowercase_								= self.prepare_config_and_inputs()
      lowercase_					,    lowercase_					,    lowercase_								= config_and_inputs
      lowercase_								= {"""pixel_values""": pixel_values}
      return config, inputs_dict







@require_torch
class    SCREAMING_SNAKE_CASE__ (							__UpperCAmelCase      ,  __UpperCAmelCase      ,  unittest.TestCase   ):
    lowercase__      =   (TimesformerModel, TimesformerForVideoClassification) if is_torch_available() else ()
    lowercase__      =   (
        {"feature-extraction": TimesformerModel, "video-classification": TimesformerForVideoClassification}
        if is_torch_available()
        else {}
    )

    lowercase__      =   False
    lowercase__      =   False
    lowercase__      =   False
    lowercase__      =   False

    def 					_UpperCAmelCase	(				self			:				Tuple):







      """simple docstring"""







      lowercase_								= TimesformerModelTester(self)
      lowercase_								= ConfigTester(
          self ,  config_class=lowerCAmelCase_ ,  has_text_modality=lowerCAmelCase_ ,  hidden_size=3_7)

    def 					_UpperCAmelCase	(				self			:				List[str] ,  lowerCAmelCase_			:				Any ,  lowerCAmelCase_			:				str ,  lowerCAmelCase_			:				List[Any]=False):







      """simple docstring"""







      lowercase_								= copy.deepcopy(lowerCAmelCase_)

      if return_labels:
        if model_class in get_values(lowerCAmelCase_):
          lowercase_								= torch.zeros(
              self.model_tester.batch_size ,  dtype=torch.long ,  device=lowerCAmelCase_)

      return inputs_dict

    def 					_UpperCAmelCase	(				self			:				List[str]):







      """simple docstring"""







      self.config_tester.run_common_tests()

    @unittest.skip(reason="""TimeSformer does not use inputs_embeds""")
    def 					_UpperCAmelCase	(				self			:				Tuple):







      """simple docstring"""







      pass

    def 					_UpperCAmelCase	(				self			:				Union[str, Any]):







      """simple docstring"""







      lowercase_					,    lowercase_								= self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowercase_								= model_class(lowerCAmelCase_)
        self.assertIsInstance(model.get_input_embeddings() ,  (nn.Module))
        lowercase_								= model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(lowerCAmelCase_ ,  nn.Linear))

    def 					_UpperCAmelCase	(				self			:				str):







      """simple docstring"""







      lowercase_					,    lowercase_								= self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowercase_								= model_class(lowerCAmelCase_)
        lowercase_								= inspect.signature(model.forward)
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        lowercase_								= [*signature.parameters.keys()]

        lowercase_								= ["""pixel_values"""]
        self.assertListEqual(arg_names[:1] ,  lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				Optional[Any]):







      """simple docstring"""







      lowercase_								= self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_video_classification(*lowerCAmelCase_)

    @slow
    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      for model_name in TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        lowercase_								= TimesformerModel.from_pretrained(lowerCAmelCase_)
        self.assertIsNotNone(lowerCAmelCase_)

    def 					_UpperCAmelCase	(				self			:				List[Any]):







      """simple docstring"""







      if not self.has_attentions:
        pass

      else:
        lowercase_					,    lowercase_								= self.model_tester.prepare_config_and_inputs_for_common()
        lowercase_								= True

        for model_class in self.all_model_classes:
          lowercase_								= self.model_tester.seq_length
          lowercase_								= self.model_tester.num_frames

          lowercase_								= True
          lowercase_								= False
          lowercase_								= True
          lowercase_								= model_class(lowerCAmelCase_)
          model.to(lowerCAmelCase_)
          model.eval()
          with torch.no_grad():
            lowercase_								= model(**self._prepare_for_class(lowerCAmelCase_ ,  lowerCAmelCase_))
          lowercase_								= outputs.attentions
          self.assertEqual(len(lowerCAmelCase_) ,  self.model_tester.num_hidden_layers)

          # check that output_attentions also work using config
          del inputs_dict["output_attentions"]
          lowercase_								= True
          lowercase_								= model_class(lowerCAmelCase_)
          model.to(lowerCAmelCase_)
          model.eval()
          with torch.no_grad():
            lowercase_								= model(**self._prepare_for_class(lowerCAmelCase_ ,  lowerCAmelCase_))
          lowercase_								= outputs.attentions
          self.assertEqual(len(lowerCAmelCase_) ,  self.model_tester.num_hidden_layers)

          # attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
          self.assertListEqual(
              list(attentions[0].shape[-3:]) ,  [self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1] ,  )
          lowercase_								= len(lowerCAmelCase_)

          # Check attention is always last and order is fine
          lowercase_								= True
          lowercase_								= True
          lowercase_								= model_class(lowerCAmelCase_)
          model.to(lowerCAmelCase_)
          model.eval()
          with torch.no_grad():
            lowercase_								= model(**self._prepare_for_class(lowerCAmelCase_ ,  lowerCAmelCase_))

          self.assertEqual(out_len + 1 ,  len(lowerCAmelCase_))

          lowercase_								= outputs.attentions

          self.assertEqual(len(lowerCAmelCase_) ,  self.model_tester.num_hidden_layers)

          # attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
          self.assertListEqual(
              list(self_attentions[0].shape[-3:]) ,  [self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1] ,  )




    def 					_UpperCAmelCase	(				self			:				List[str]):







      """simple docstring"""







      def check_hidden_states_output(lowerCAmelCase_			:				Union[str, Any] ,  lowerCAmelCase_			:				List[Any] ,  lowerCAmelCase_			:				List[Any]):
        lowercase_								= model_class(lowerCAmelCase_)
        model.to(lowerCAmelCase_)
        model.eval()

        with torch.no_grad():
          lowercase_								= model(**self._prepare_for_class(lowerCAmelCase_ ,  lowerCAmelCase_))

        lowercase_								= outputs.hidden_states
        lowercase_								= self.model_tester.num_hidden_layers + 1
        self.assertEqual(len(lowerCAmelCase_) ,  lowerCAmelCase_)

        lowercase_								= self.model_tester.seq_length

        self.assertListEqual(
            list(hidden_states[0].shape[-2:]) ,  [seq_length, self.model_tester.hidden_size] ,  )

      lowercase_					,    lowercase_								= self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowercase_								= True
        check_hidden_states_output(lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_)

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        lowercase_								= True

        check_hidden_states_output(lowerCAmelCase_ ,  lowerCAmelCase_ ,  lowerCAmelCase_)







def 			_SCREAMING_SNAKE_CASE						() ->						List[str]:







  '''simple docstring'''


  lowercase_								= hf_hub_download(
      repo_id="""hf-internal-testing/spaghetti-video""" ,  filename="""eating_spaghetti.npy""" ,  repo_type="""dataset"""							)
  lowercase_								= np.load(__lowerCAmelCase							)
  return list(__lowerCAmelCase							)


@require_torch
@require_vision
class    SCREAMING_SNAKE_CASE__ (							unittest.TestCase   ):

    @cached_property
    def 					_UpperCAmelCase	(				self			:				int):







      """simple docstring"""







      return (
          VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5] ,  image_std=[0.5, 0.5, 0.5])
          if is_vision_available()
          else None
      )




    @slow
    def 					_UpperCAmelCase	(				self			:				List[Any]):







      """simple docstring"""







      lowercase_								= TimesformerForVideoClassification.from_pretrained("""facebook/timesformer-base-finetuned-k400""").to(
          lowerCAmelCase_)

      lowercase_								= self.default_image_processor
      lowercase_								= prepare_video()
      lowercase_								= image_processor(video[:8] ,  return_tensors="""pt""").to(lowerCAmelCase_)

      # forward pass
      with torch.no_grad():
        lowercase_								= model(**lowerCAmelCase_)

      # verify the logits
      lowercase_								= torch.Size((1, 4_0_0))
      self.assertEqual(outputs.logits.shape ,  lowerCAmelCase_)

      lowercase_								= torch.tensor([-0.3_016, -0.7_713, -0.4_205]).to(lowerCAmelCase_)

      self.assertTrue(torch.allclose(outputs.logits[0, :3] ,  lowerCAmelCase_ ,  atol=1E-4))






"""simple docstring"""
def 			_SCREAMING_SNAKE_CASE						(__lowerCAmelCase=2_81_23							) ->						Optional[Any]:







  '''simple docstring'''


  lowercase_								= [1] * (limit + 1)

  for i in range(2 ,  int(limit**0.5							) + 1							):
    sum_divs[i * i] += i
    for k in range(i + 1 ,  limit // i + 1							):
      sum_divs[k * i] += k + i

  lowercase_								= set()
  lowercase_								= 0

  for n in range(1 ,  limit + 1							):
    if sum_divs[n] > n:
      abundants.add(__lowerCAmelCase							)

    if not any((n - a in abundants) for a in abundants							):
      res += n

  return res


if __name__ == "__main__":
       print(solution())

