
"""simple docstring"""





import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import VideoMAEConfig
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,
							    VideoMAEForPreTraining,
							    VideoMAEForVideoClassification,
							    VideoMAEModel,
							)
							from transformers.models.videomae.modeling_videomae import VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from transformers import VideoMAEImageProcessor
class 						SCREAMING_SNAKE_CASE_ :




		"""simple docstring"""





		def __init__(     self							,  lowerCAmelCase__							,  lowerCAmelCase__=1_3							,  lowerCAmelCase__=1_0							,  lowerCAmelCase__=3							,  lowerCAmelCase__=2							,  lowerCAmelCase__=2							,  lowerCAmelCase__=2							,  lowerCAmelCase__=True							,  lowerCAmelCase__=True							,  lowerCAmelCase__=3_2							,  lowerCAmelCase__=5							,  lowerCAmelCase__=4							,  lowerCAmelCase__=3_7							,  lowerCAmelCase__="gelu"							,  lowerCAmelCase__=0.1							,  lowerCAmelCase__=0.1							,  lowerCAmelCase__=1_0							,  lowerCAmelCase__=0.02							,  lowerCAmelCase__=0.9							,  lowerCAmelCase__=None							,  ):
				__SCREAMING_SNAKE_CASE            = parent
				__SCREAMING_SNAKE_CASE            = batch_size
				__SCREAMING_SNAKE_CASE            = image_size
				__SCREAMING_SNAKE_CASE            = num_channels
				__SCREAMING_SNAKE_CASE            = patch_size
				__SCREAMING_SNAKE_CASE            = tubelet_size
				__SCREAMING_SNAKE_CASE            = num_frames
				__SCREAMING_SNAKE_CASE            = is_training
				__SCREAMING_SNAKE_CASE            = use_labels
				__SCREAMING_SNAKE_CASE            = hidden_size
				__SCREAMING_SNAKE_CASE            = num_hidden_layers
				__SCREAMING_SNAKE_CASE            = num_attention_heads
				__SCREAMING_SNAKE_CASE            = intermediate_size
				__SCREAMING_SNAKE_CASE            = hidden_act
				__SCREAMING_SNAKE_CASE            = hidden_dropout_prob
				__SCREAMING_SNAKE_CASE            = attention_probs_dropout_prob
				__SCREAMING_SNAKE_CASE            = type_sequence_label_size
				__SCREAMING_SNAKE_CASE            = initializer_range
				__SCREAMING_SNAKE_CASE            = mask_ratio
				__SCREAMING_SNAKE_CASE            = scope

				# in VideoMAE, the number of tokens equals num_frames/tubelet_size * num_patches per frame
				__SCREAMING_SNAKE_CASE            = (image_size // patch_size) ** 2
				__SCREAMING_SNAKE_CASE            = (num_frames // tubelet_size) * self.num_patches_per_frame

				# use this variable to define bool_masked_pos
				__SCREAMING_SNAKE_CASE            = int(mask_ratio * self.seq_length)




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = floats_tensor(
				    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size])

				__SCREAMING_SNAKE_CASE            = None
				if self.use_labels:
						__SCREAMING_SNAKE_CASE            = ids_tensor([self.batch_size]							,  self.type_sequence_label_size)

				__SCREAMING_SNAKE_CASE            = self.get_config()

				return config, pixel_values, labels




		def 	snake_case_     (     self):
				return VideoMAEConfig(
				    image_size=self.image_size							,  patch_size=self.patch_size							,  num_channels=self.num_channels							,  num_frames=self.num_frames							,  tubelet_size=self.tubelet_size							,  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							,  is_decoder=lowerCAmelCase__							,  initializer_range=self.initializer_range							,  )




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__):
				__SCREAMING_SNAKE_CASE            = VideoMAEModel(config=lowerCAmelCase__)
				model.to(lowerCAmelCase__)
				model.eval()
				__SCREAMING_SNAKE_CASE            = model(lowerCAmelCase__)
				self.parent.assertEqual(result.last_hidden_state.shape							,  (self.batch_size, self.seq_length, self.hidden_size))




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__):
				__SCREAMING_SNAKE_CASE            = VideoMAEForPreTraining(lowerCAmelCase__)
				model.to(lowerCAmelCase__)
				model.eval()
				# important: each video needs to have the same number of masked patches
				# hence we define a single mask, which we then repeat for each example in the batch
				__SCREAMING_SNAKE_CASE            = torch.ones((self.num_masks,))
				__SCREAMING_SNAKE_CASE            = torch.cat([mask, torch.zeros(self.seq_length - mask.size(0))])
				__SCREAMING_SNAKE_CASE            = mask.expand(self.batch_size							,  -1).bool()

				__SCREAMING_SNAKE_CASE            = model(lowerCAmelCase__							,  lowerCAmelCase__)
				# model only returns predictions for masked patches
				__SCREAMING_SNAKE_CASE            = mask.sum().item()
				__SCREAMING_SNAKE_CASE            = 3 * self.tubelet_size * self.patch_size**2
				self.parent.assertEqual(result.logits.shape							,  (self.batch_size, num_masked_patches, decoder_num_labels))




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



@require_torch
class 						SCREAMING_SNAKE_CASE_ (						__a     ,				__a     ,				unittest.TestCase ):




		"""simple docstring"""





		__lowercase							:  Tuple						   =		(
		    (VideoMAEModel, VideoMAEForPreTraining, VideoMAEForVideoClassification) if is_torch_available() else ()
		)
		__lowercase							:  int						   =		(
		    {'''feature-extraction''': VideoMAEModel, '''video-classification''': VideoMAEForVideoClassification}
		    if is_torch_available()
		    else {}
		)

		__lowercase							:  int						   =		False
		__lowercase							:  Optional[int]						   =		False
		__lowercase							:  Optional[Any]						   =		False
		__lowercase							:  Optional[Any]						   =		False




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = VideoMAEModelTester(self)
				__SCREAMING_SNAKE_CASE            = ConfigTester(self							,  config_class=lowerCAmelCase__							,  has_text_modality=lowerCAmelCase__							,  hidden_size=3_7)




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__=False):
				__SCREAMING_SNAKE_CASE            = copy.deepcopy(lowerCAmelCase__)

				if model_class == VideoMAEForPreTraining:
						# important: each video needs to have the same number of masked patches
						# hence we define a single mask, which we then repeat for each example in the batch
						__SCREAMING_SNAKE_CASE            = torch.ones((self.model_tester.num_masks,))
						__SCREAMING_SNAKE_CASE            = torch.cat([mask, torch.zeros(self.model_tester.seq_length - mask.size(0))])
						__SCREAMING_SNAKE_CASE            = mask.expand(self.model_tester.batch_size							,  -1).bool()
						__SCREAMING_SNAKE_CASE            = bool_masked_pos.to(lowerCAmelCase__)

				if return_labels:
						if model_class in [
						    *get_values(lowerCAmelCase__),
						]:
								__SCREAMING_SNAKE_CASE            = torch.zeros(
								    self.model_tester.batch_size							,  dtype=torch.long							,  device=lowerCAmelCase__)

				return inputs_dict




		def 	snake_case_     (     self):
				self.config_tester.run_common_tests()




		@unittest.skip(reason="""VideoMAE does not use inputs_embeds""")
		def 	snake_case_     (     self):
				pass




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = self.model_tester.prepare_config_and_inputs_for_common()

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




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = self.model_tester.prepare_config_and_inputs_for_common()

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

						__SCREAMING_SNAKE_CASE            = ["""pixel_values"""]
						self.assertListEqual(arg_names[:1]							,  lowerCAmelCase__)




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*lowerCAmelCase__)




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_pretraining(*lowerCAmelCase__)




		@slow
		def 	snake_case_     (     self):
				for model_name in VIDEOMAE_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						__SCREAMING_SNAKE_CASE            = VideoMAEModel.from_pretrained(lowerCAmelCase__)
						self.assertIsNotNone(lowerCAmelCase__)




		def 	snake_case_     (     self):
				if not self.has_attentions:
						pass

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

						for model_class in self.all_model_classes:
								__SCREAMING_SNAKE_CASE            = self.model_tester.seq_length - self.model_tester.num_masks
								__SCREAMING_SNAKE_CASE            = (
								    num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length
								)

								__SCREAMING_SNAKE_CASE            = True
								__SCREAMING_SNAKE_CASE            = False
								__SCREAMING_SNAKE_CASE            = True
								__SCREAMING_SNAKE_CASE            = model_class(lowerCAmelCase__)
								model.to(lowerCAmelCase__)
								model.eval()
								with torch.no_grad():
										__SCREAMING_SNAKE_CASE            = model(**self._prepare_for_class(lowerCAmelCase__							,  lowerCAmelCase__))
								__SCREAMING_SNAKE_CASE            = 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"]
								__SCREAMING_SNAKE_CASE            = True
								__SCREAMING_SNAKE_CASE            = model_class(lowerCAmelCase__)
								model.to(lowerCAmelCase__)
								model.eval()
								with torch.no_grad():
										__SCREAMING_SNAKE_CASE            = model(**self._prepare_for_class(lowerCAmelCase__							,  lowerCAmelCase__))
								__SCREAMING_SNAKE_CASE            = outputs.attentions
								self.assertEqual(len(lowerCAmelCase__)							,  self.model_tester.num_hidden_layers)

								self.assertListEqual(
								    list(attentions[0].shape[-3:])							,  [self.model_tester.num_attention_heads, seq_len, seq_len]							,  )
								__SCREAMING_SNAKE_CASE            = len(lowerCAmelCase__)

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

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

								__SCREAMING_SNAKE_CASE            = outputs.attentions

								self.assertEqual(len(lowerCAmelCase__)							,  self.model_tester.num_hidden_layers)
								self.assertListEqual(
								    list(self_attentions[0].shape[-3:])							,  [self.model_tester.num_attention_heads, seq_len, seq_len]							,  )




		def 	snake_case_     (     self):
				def check_hidden_states_output(lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__):
						__SCREAMING_SNAKE_CASE            = model_class(lowerCAmelCase__)
						model.to(lowerCAmelCase__)
						model.eval()

						with torch.no_grad():
								__SCREAMING_SNAKE_CASE            = model(**self._prepare_for_class(lowerCAmelCase__							,  lowerCAmelCase__))

						__SCREAMING_SNAKE_CASE            = outputs.hidden_states
						__SCREAMING_SNAKE_CASE            = self.model_tester.num_hidden_layers + 1
						self.assertEqual(len(lowerCAmelCase__)							,  lowerCAmelCase__)

						__SCREAMING_SNAKE_CASE            = self.model_tester.seq_length - self.model_tester.num_masks
						__SCREAMING_SNAKE_CASE            = num_visible_patches if model_class == VideoMAEForPreTraining else self.model_tester.seq_length

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

				__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE            = self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						__SCREAMING_SNAKE_CASE            = True
						check_hidden_states_output(lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__)

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

						check_hidden_states_output(lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__)




		@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests.""")
		def 	snake_case_     (     self):
				pass



def 						_lowerCAmelCase				(				):
		__SCREAMING_SNAKE_CASE            = hf_hub_download(
		    repo_id="""hf-internal-testing/spaghetti-video"""  ,				filename="""eating_spaghetti.npy"""  ,				repo_type="""dataset"""				)
		__SCREAMING_SNAKE_CASE            = np.load(UpperCamelCase_				)
		return list(UpperCamelCase_				)
@require_torch
@require_vision
class 						SCREAMING_SNAKE_CASE_ (						unittest.TestCase ):




		"""simple docstring"""





		@cached_property
		def 	snake_case_     (     self):
				# logits were tested with a different mean and std, so we use the same here
				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 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = VideoMAEForVideoClassification.from_pretrained("""MCG-NJU/videomae-base-finetuned-kinetics""").to(
				    lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = self.default_image_processor
				__SCREAMING_SNAKE_CASE            = prepare_video()
				__SCREAMING_SNAKE_CASE            = image_processor(lowerCAmelCase__							,  return_tensors="""pt""").to(lowerCAmelCase__)

				# forward pass
				with torch.no_grad():
						__SCREAMING_SNAKE_CASE            = model(**lowerCAmelCase__)

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

				__SCREAMING_SNAKE_CASE            = torch.tensor([0.36_69, -0.06_88, -0.24_21]).to(lowerCAmelCase__)

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




		@slow
		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = VideoMAEForPreTraining.from_pretrained("""MCG-NJU/videomae-base-short""").to(lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = self.default_image_processor
				__SCREAMING_SNAKE_CASE            = prepare_video()
				__SCREAMING_SNAKE_CASE            = image_processor(lowerCAmelCase__							,  return_tensors="""pt""").to(lowerCAmelCase__)

				# add boolean mask, indicating which patches to mask
				__SCREAMING_SNAKE_CASE            = hf_hub_download(repo_id="""hf-internal-testing/bool-masked-pos"""							,  filename="""bool_masked_pos.pt""")
				__SCREAMING_SNAKE_CASE            = torch.load(lowerCAmelCase__)

				# forward pass
				with torch.no_grad():
						__SCREAMING_SNAKE_CASE            = model(**lowerCAmelCase__)

				# verify the logits
				__SCREAMING_SNAKE_CASE            = torch.Size([1, 1_4_0_8, 1_5_3_6])
				__SCREAMING_SNAKE_CASE            = torch.tensor(
				    [[0.79_94, 0.96_12, 0.85_08], [0.74_01, 0.89_58, 0.83_02], [0.58_62, 0.74_68, 0.73_25]]							,  device=lowerCAmelCase__)
				self.assertEqual(outputs.logits.shape							,  lowerCAmelCase__)
				self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]							,  lowerCAmelCase__							,  atol=1E-4))

				# verify the loss (`config.norm_pix_loss` = `True`)
				__SCREAMING_SNAKE_CASE            = torch.tensor([0.51_42]							,  device=lowerCAmelCase__)
				self.assertTrue(torch.allclose(outputs.loss							,  lowerCAmelCase__							,  atol=1E-4))

				# verify the loss (`config.norm_pix_loss` = `False`)
				__SCREAMING_SNAKE_CASE            = VideoMAEForPreTraining.from_pretrained("""MCG-NJU/videomae-base-short"""							,  norm_pix_loss=lowerCAmelCase__).to(
				    lowerCAmelCase__)

				with torch.no_grad():
						__SCREAMING_SNAKE_CASE            = model(**lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = torch.tensor(torch.tensor([0.64_69])							,  device=lowerCAmelCase__)
				self.assertTrue(torch.allclose(outputs.loss							,  lowerCAmelCase__							,  atol=1E-4))






"""simple docstring"""





from math import isqrt, loga



def 						_lowerCAmelCase				(				UpperCamelCase_				):
		__SCREAMING_SNAKE_CASE            = [True] * max_number
		for i in range(2  ,				isqrt(max_number - 1				) + 1				):
				if is_prime[i]:
						for j in range(i**2  ,				UpperCamelCase_  ,				UpperCamelCase_				):
								__SCREAMING_SNAKE_CASE            = False

		return [i for i in range(2  ,				UpperCamelCase_				) if is_prime[i]]



def 						_lowerCAmelCase				(				UpperCamelCase_ = 80_0800  ,				UpperCamelCase_ = 80_0800				):
		__SCREAMING_SNAKE_CASE            = degree * loga(UpperCamelCase_				)
		__SCREAMING_SNAKE_CASE            = int(UpperCamelCase_				)
		__SCREAMING_SNAKE_CASE            = calculate_prime_numbers(UpperCamelCase_				)

		__SCREAMING_SNAKE_CASE            = 0
		__SCREAMING_SNAKE_CASE            = 0
		__SCREAMING_SNAKE_CASE            = len(UpperCamelCase_				) - 1
		while left < right:
				while (
				    prime_numbers[right] * loga(prime_numbers[left]				)
				    + prime_numbers[left] * loga(prime_numbers[right]				)
				    > upper_bound
				):
						right -= 1
				hybrid_integers_count += right - left
				left += 1

		return hybrid_integers_count


if __name__ == "__main__":
							print(F"""{solution() = }""")




