
'''simple docstring'''





import math
from collections.abc import Iterator
from itertools import takewhile

def      A (       A_							:					Optional[Any]       ):






						if 1 < number < 4:
												# 2 and 3 are primes
												return True
						elif number < 2 or number % 2 == 0 or number % 3 == 0:
												# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
												return False

						# All primes number are in format of 6k +/- 1
						for i in range(5    ,							int(math.sqrt(a__       ) + 1       )    ,							6       ):
												if number % i == 0 or number % (i + 2) == 0:
																		return False
						return True

def      A (       ):
						snake_case       :     List[Any] =    2
						while True:
												if is_prime(a__       ):
																		yield num
												num += 1

def      A (       A_							:					int = 2000000       ):
						return sum(takewhile(lambda A_       : x < n    ,							prime_generator()       )       )


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

'''simple docstring'''





import inspect
import unittest

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

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


if is_torch_available():
						import torch
						from torch import nn

						from transformers import MODEL_MAPPING, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTModel
						from transformers.models.dpt.modeling_dpt import DPT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
						from PIL import Image

						from transformers import DPTImageProcessor

class 						a   :




				def __init__(							self	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				str,    SCREAMING_SNAKE_CASE_	:				List[Any]=2,    SCREAMING_SNAKE_CASE_	:				str=32,    SCREAMING_SNAKE_CASE_	:				Union[str, Any]=16,    SCREAMING_SNAKE_CASE_	:				str=3,    SCREAMING_SNAKE_CASE_	:				Union[str, Any]=True,    SCREAMING_SNAKE_CASE_	:				int=True,    SCREAMING_SNAKE_CASE_	:				Optional[Any]=32,    SCREAMING_SNAKE_CASE_	:				Any=4,    SCREAMING_SNAKE_CASE_	:				Dict=[0, 1, 2, 3],    SCREAMING_SNAKE_CASE_	:				Dict=4,    SCREAMING_SNAKE_CASE_	:				Union[str, Any]=37,    SCREAMING_SNAKE_CASE_	:				str="gelu",    SCREAMING_SNAKE_CASE_	:				Optional[int]=0.1,    SCREAMING_SNAKE_CASE_	:				List[Any]=0.1,    SCREAMING_SNAKE_CASE_	:				Dict=0.02,    SCREAMING_SNAKE_CASE_	:				int=3,    SCREAMING_SNAKE_CASE_	:				List[str]=[1, 3_84, 24, 24],    SCREAMING_SNAKE_CASE_	:				Optional[int]=True,    SCREAMING_SNAKE_CASE_	:				Optional[int]=None,    ):
										snake_case       :     int =    parent
										snake_case       :     Tuple =    batch_size
										snake_case       :     List[str] =    image_size
										snake_case       :     Union[str, Any] =    patch_size
										snake_case       :     Dict =    num_channels
										snake_case       :     int =    is_training
										snake_case       :     Any =    use_labels
										snake_case       :     Any =    hidden_size
										snake_case       :     Union[str, Any] =    num_hidden_layers
										snake_case       :     Tuple =    backbone_out_indices
										snake_case       :     Dict =    num_attention_heads
										snake_case       :     Optional[Any] =    intermediate_size
										snake_case       :     Any =    hidden_act
										snake_case       :     List[str] =    hidden_dropout_prob
										snake_case       :     List[str] =    attention_probs_dropout_prob
										snake_case       :     Tuple =    initializer_range
										snake_case       :     Any =    num_labels
										snake_case       :     Union[str, Any] =    backbone_featmap_shape
										snake_case       :     Optional[int] =    scope
										snake_case       :     Tuple =    is_hybrid
										# sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
										snake_case       :     Dict =    (image_size // patch_size) ** 2
										snake_case       :     Any =    num_patches + 1




				def 	__snake_case							(							self	:				List[Any]      ):
										snake_case       :     Optional[Any] =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

										snake_case       :     Union[str, Any] =    None
										if self.use_labels:
																snake_case       :     List[Any] =    ids_tensor([self.batch_size, self.image_size, self.image_size],    self.num_labels      )

										snake_case       :     Optional[int] =    self.get_config()

										return config, pixel_values, labels




				def 	__snake_case							(							self	:				List[str]      ):
										snake_case       :     Optional[int] =    {
										    '''global_padding''': '''same''',
										    '''layer_type''': '''bottleneck''',
										    '''depths''': [3, 4, 9],
										    '''out_features''': ['''stage1''', '''stage2''', '''stage3'''],
										    '''embedding_dynamic_padding''': True,
										    '''hidden_sizes''': [96, 1_92, 3_84, 7_68],
										    '''num_groups''': 2,
										}

										return DPTConfig(
										    image_size=self.image_size,    patch_size=self.patch_size,    num_channels=self.num_channels,    hidden_size=self.hidden_size,    num_hidden_layers=self.num_hidden_layers,    backbone_out_indices=self.backbone_out_indices,    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=SCREAMING_SNAKE_CASE_,    initializer_range=self.initializer_range,    is_hybrid=self.is_hybrid,    backbone_config=SCREAMING_SNAKE_CASE_,    backbone_featmap_shape=self.backbone_featmap_shape,    )




				def 	__snake_case							(							self	:				List[Any],    SCREAMING_SNAKE_CASE_	:				Dict,    SCREAMING_SNAKE_CASE_	:				str,    SCREAMING_SNAKE_CASE_	:				Any      ):
										snake_case       :     Dict =    DPTModel(config=SCREAMING_SNAKE_CASE_      )
										model.to(SCREAMING_SNAKE_CASE_      )
										model.eval()
										snake_case       :     List[Any] =    model(SCREAMING_SNAKE_CASE_      )
										self.parent.assertEqual(result.last_hidden_state.shape,    (self.batch_size, self.seq_length, self.hidden_size)      )




				def 	__snake_case							(							self	:				Tuple,    SCREAMING_SNAKE_CASE_	:				Optional[Any],    SCREAMING_SNAKE_CASE_	:				Dict,    SCREAMING_SNAKE_CASE_	:				Optional[Any]      ):
										snake_case       :     int =    self.num_labels
										snake_case       :     Any =    DPTForDepthEstimation(SCREAMING_SNAKE_CASE_      )
										model.to(SCREAMING_SNAKE_CASE_      )
										model.eval()
										snake_case       :     Union[str, Any] =    model(SCREAMING_SNAKE_CASE_      )
										self.parent.assertEqual(result.predicted_depth.shape,    (self.batch_size, self.image_size, self.image_size)      )




				def 	__snake_case							(							self	:				Optional[int],    SCREAMING_SNAKE_CASE_	:				Optional[Any],    SCREAMING_SNAKE_CASE_	:				List[Any],    SCREAMING_SNAKE_CASE_	:				List[Any]      ):
										snake_case       :     List[str] =    self.num_labels
										snake_case       :     List[Any] =    DPTForSemanticSegmentation(SCREAMING_SNAKE_CASE_      )
										model.to(SCREAMING_SNAKE_CASE_      )
										model.eval()
										snake_case       :     Union[str, Any] =    model(SCREAMING_SNAKE_CASE_,    labels=SCREAMING_SNAKE_CASE_      )
										self.parent.assertEqual(
										    result.logits.shape,    (self.batch_size, self.num_labels, self.image_size, self.image_size)      )




				def 	__snake_case							(							self	:				Union[str, Any]      ):
										snake_case       :     Optional[int] =    self.prepare_config_and_inputs()
										snake_case,					snake_case,					snake_case       :     Tuple =    config_and_inputs
										snake_case       :     List[str] =    {'''pixel_values''': pixel_values}
										return config, inputs_dict




@require_torch
class 						a   (				__magic_name__				,__magic_name__				,unittest.TestCase    ):
				_snake_case		    = (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
				_snake_case		    = (
				    {
				        '''depth-estimation''': DPTForDepthEstimation,
				        '''feature-extraction''': DPTModel,
				        '''image-segmentation''': DPTForSemanticSegmentation,
				    }
				    if is_torch_available()
				    else {}
				)

				_snake_case		    = False
				_snake_case		    = False
				_snake_case		    = False




				def 	__snake_case							(							self	:				Any      ):
										snake_case       :     Optional[Any] =    DPTModelTester(self      )
										snake_case       :     Any =    ConfigTester(self,    config_class=SCREAMING_SNAKE_CASE_,    has_text_modality=SCREAMING_SNAKE_CASE_,    hidden_size=37      )




				def 	__snake_case							(							self	:				Dict      ):
										self.config_tester.run_common_tests()




				@unittest.skip(reason='''DPT does not use inputs_embeds'''      )
				def 	__snake_case							(							self	:				int      ):
										pass




				def 	__snake_case							(							self	:				List[str]      ):
										snake_case,					snake_case       :     str =    self.model_tester.prepare_config_and_inputs_for_common()

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




				def 	__snake_case							(							self	:				Tuple      ):
										snake_case,					snake_case       :     Optional[int] =    self.model_tester.prepare_config_and_inputs_for_common()

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

																snake_case       :     Union[str, Any] =    ['''pixel_values''']
																self.assertListEqual(arg_names[:1],    SCREAMING_SNAKE_CASE_      )




				def 	__snake_case							(							self	:				List[str]      ):
										snake_case       :     Tuple =    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_      )




				def 	__snake_case							(							self	:				Tuple      ):
										snake_case       :     List[Any] =    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_depth_estimation(*SCREAMING_SNAKE_CASE_      )




				def 	__snake_case							(							self	:				Dict      ):
										snake_case       :     Tuple =    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_semantic_segmentation(*SCREAMING_SNAKE_CASE_      )




				def 	__snake_case							(							self	:				Any      ):
										for model_class in self.all_model_classes:
																if model_class.__name__ == "DPTForDepthEstimation":
																						continue

																snake_case,					snake_case       :     Optional[Any] =    self.model_tester.prepare_config_and_inputs_for_common()
																snake_case       :     Dict =    True

																if model_class in get_values(SCREAMING_SNAKE_CASE_      ):
																						continue

																snake_case       :     Tuple =    model_class(SCREAMING_SNAKE_CASE_      )
																model.to(SCREAMING_SNAKE_CASE_      )
																model.train()
																snake_case       :     Any =    self._prepare_for_class(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    return_labels=SCREAMING_SNAKE_CASE_      )
																snake_case       :     Dict =    model(**SCREAMING_SNAKE_CASE_      ).loss
																loss.backward()




				def 	__snake_case							(							self	:				int      ):
										for model_class in self.all_model_classes:
																if model_class.__name__ == "DPTForDepthEstimation":
																						continue

																snake_case,					snake_case       :     Any =    self.model_tester.prepare_config_and_inputs_for_common()
																snake_case       :     Dict =    False
																snake_case       :     Dict =    True

																if model_class in get_values(SCREAMING_SNAKE_CASE_      ) or not model_class.supports_gradient_checkpointing:
																						continue
																snake_case       :     Optional[Any] =    model_class(SCREAMING_SNAKE_CASE_      )
																model.to(SCREAMING_SNAKE_CASE_      )
																model.gradient_checkpointing_enable()
																model.train()
																snake_case       :     Union[str, Any] =    self._prepare_for_class(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    return_labels=SCREAMING_SNAKE_CASE_      )
																snake_case       :     List[str] =    model(**SCREAMING_SNAKE_CASE_      ).loss
																loss.backward()




				def 	__snake_case							(							self	:				Tuple      ):
										snake_case,					snake_case       :     List[str] =    self.model_tester.prepare_config_and_inputs_for_common()

										snake_case       :     Union[str, Any] =    _config_zero_init(SCREAMING_SNAKE_CASE_      )
										for model_class in self.all_model_classes:
																snake_case       :     List[str] =    model_class(config=SCREAMING_SNAKE_CASE_      )
																# Skip the check for the backbone
																snake_case       :     Optional[int] =    []
																for name, module in model.named_modules():
																						if module.__class__.__name__ == "DPTViTHybridEmbeddings":
																												snake_case       :     List[Any] =    [F"""{name}.{key}""" for key in module.state_dict().keys()]
																												break

																for name, param in model.named_parameters():
																						if param.requires_grad:
																												if name in backbone_params:
																																		continue
																												self.assertIn(
																												    ((param.data.mean() * 1e9).round() / 1e9).item(),    [0.0, 1.0],    msg=F"""Parameter {name} of model {model_class} seems not properly initialized""",    )




				@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''      )
				def 	__snake_case							(							self	:				Union[str, Any]      ):
										pass




				@slow
				def 	__snake_case							(							self	:				List[Any]      ):
										for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]:
																snake_case       :     int =    DPTModel.from_pretrained(SCREAMING_SNAKE_CASE_      )
																self.assertIsNotNone(SCREAMING_SNAKE_CASE_      )




				def 	__snake_case							(							self	:				Dict      ):
										# We do this test only for DPTForDepthEstimation since it is the only model that uses readout_type
										snake_case,					snake_case       :     str =    self.model_tester.prepare_config_and_inputs_for_common()
										snake_case       :     int =    '''add'''
										with self.assertRaises(SCREAMING_SNAKE_CASE_      ):
																snake_case       :     Any =    DPTForDepthEstimation(SCREAMING_SNAKE_CASE_      )




def      A (       ):
						snake_case       :     int =    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       )
						return image





@require_torch
@require_vision
@slow
class 						a   (				unittest.TestCase    ):




				def 	__snake_case							(							self	:				Dict      ):
										snake_case       :     Dict =    DPTImageProcessor.from_pretrained('''Intel/dpt-hybrid-midas'''      )
										snake_case       :     int =    DPTForDepthEstimation.from_pretrained('''Intel/dpt-hybrid-midas'''      ).to(SCREAMING_SNAKE_CASE_      )

										snake_case       :     str =    prepare_img()
										snake_case       :     List[str] =    image_processor(images=SCREAMING_SNAKE_CASE_,    return_tensors='''pt'''      ).to(SCREAMING_SNAKE_CASE_      )

										# forward pass
										with torch.no_grad():
																snake_case       :     List[Any] =    model(**SCREAMING_SNAKE_CASE_      )
																snake_case       :     Optional[Any] =    outputs.predicted_depth

										# verify the predicted depth
										snake_case       :     List[str] =    torch.Size((1, 3_84, 3_84)      )
										self.assertEqual(predicted_depth.shape,    SCREAMING_SNAKE_CASE_      )

										snake_case       :     Dict =    torch.tensor(
										    [[[5.6437, 5.6146, 5.6511], [5.4371, 5.5649, 5.5958], [5.5215, 5.5184, 5.5293]]]      ).to(SCREAMING_SNAKE_CASE_      )

										self.assertTrue(torch.allclose(outputs.predicted_depth[:3, :3, :3] / 1_00,    SCREAMING_SNAKE_CASE_,    atol=1e-4      )      )

