import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType







@require_torch
class        UpperCAmelCase_					:
    UpperCAmelCase_      :							int    			=				()
    UpperCAmelCase_      :							Tuple    			=				True




    def     __lowerCamelCase			(       self	: Dict )						->			Optional[int]:
      a__  		=  self.config_class

      # test default config
      a__  		=  config_class()
      self.assertIsNotNone(lowerCAmelCase )
      a__  		=  ["stem"] + [f"stage{idx}" for idx in range(1   ,   len(config.depths ) + 1 )]
      self.assertEqual(config.stage_names   ,   lowerCAmelCase )
      self.assertTrue(set(config.out_features ).issubset(set(config.stage_names ) ) )

      # Test out_features and out_indices are correctly set
      # out_features and out_indices both None
      a__  		=  config_class(out_features=lowerCAmelCase   ,   out_indices=lowerCAmelCase )
      self.assertEqual(config.out_features   ,   [config.stage_names[-1]] )
      self.assertEqual(config.out_indices   ,   [len(config.stage_names ) - 1] )

      # out_features and out_indices both set
      a__  		=  config_class(out_features=["stem", "stage1"]   ,   out_indices=[0, 1] )
      self.assertEqual(config.out_features   ,   ["stem", "stage1"] )
      self.assertEqual(config.out_indices   ,   [0, 1] )

      # Only out_features set
      a__  		=  config_class(out_features=["stage1", "stage3"] )
      self.assertEqual(config.out_features   ,   ["stage1", "stage3"] )
      self.assertEqual(config.out_indices   ,   [1, 3] )

      # Only out_indices set
      a__  		=  config_class(out_indices=[0, 2] )
      self.assertEqual(config.out_features   ,   [config.stage_names[0], config.stage_names[2]] )
      self.assertEqual(config.out_indices   ,   [0, 2] )

      # Error raised when out_indices do not correspond to out_features
      with self.assertRaises(lowerCAmelCase ):
        a__  		=  config_class(out_features=["stage1", "stage2"]   ,   out_indices=[0, 2] )




    def     __lowerCamelCase			(       self	: Tuple )						->			int:
      a__		,a__  		=  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        a__  		=  model_class(lowerCAmelCase )
        a__  		=  inspect.signature(model.forward )
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        a__  		=  [*signature.parameters.keys()]
        a__  		=  ["pixel_values"]
        self.assertListEqual(arg_names[:1]   ,   lowerCAmelCase )




    def     __lowerCamelCase			(       self	: List[Any] )						->			str:
      a__		,a__  		=  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        a__  		=  model_class(lowerCAmelCase )
        self.assertEqual(len(model.channels )   ,   len(config.out_features ) )
        a__  		=  model.num_features
        a__  		=  [config.stage_names.index(lowerCAmelCase ) for feat in config.out_features]
        a__  		=  [num_features[idx] for idx in out_indices]
        self.assertListEqual(model.channels   ,   lowerCAmelCase )

        a__  		=  copy.deepcopy(lowerCAmelCase )
        a__  		=  None
        a__  		=  model_class(lowerCAmelCase )
        self.assertEqual(len(model.channels )   ,   1 )
        self.assertListEqual(model.channels   ,   [num_features[-1]] )

        a__  		=  copy.deepcopy(lowerCAmelCase )
        a__  		=  None
        a__  		=  model_class(lowerCAmelCase )
        self.assertEqual(len(model.channels )   ,   1 )
        self.assertListEqual(model.channels   ,   [num_features[-1]] )




    def     __lowerCamelCase			(       self	: Optional[int] )						->			Tuple:
      a__		,a__  		=  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        a__  		=  model_class(lowerCAmelCase )
        model.to(lowerCAmelCase )
        model.eval()
        a__  		=  model(**lowerCAmelCase )

        self.assertEqual(len(result.feature_maps )   ,   len(config.out_features ) )
        self.assertEqual(len(model.channels )   ,   len(config.out_features ) )
        self.assertEqual(len(result.feature_maps )   ,   len(config.out_indices ) )
        self.assertEqual(len(model.channels )   ,   len(config.out_indices ) )

        # Check output of last stage is taken if out_features=None, out_indices=None
        a__  		=  copy.deepcopy(lowerCAmelCase )
        a__  		=  None
        a__  		=  model_class(lowerCAmelCase )
        model.to(lowerCAmelCase )
        model.eval()
        a__  		=  model(**lowerCAmelCase )

        self.assertEqual(len(result.feature_maps )   ,   1 )
        self.assertEqual(len(model.channels )   ,   1 )

        a__  		=  copy.deepcopy(lowerCAmelCase )
        a__  		=  None
        a__  		=  model_class(lowerCAmelCase )
        model.to(lowerCAmelCase )
        model.eval()
        a__  		=  model(**lowerCAmelCase )

        self.assertEqual(len(result.feature_maps )   ,   1 )
        self.assertEqual(len(model.channels )   ,   1 )

        # Check backbone can be initialized with fresh weights
        a__  		=  copy.deepcopy(lowerCAmelCase )
        a__  		=  False
        a__  		=  model_class(lowerCAmelCase )
        model.to(lowerCAmelCase )
        model.eval()
        a__  		=  model(**lowerCAmelCase )




    def     __lowerCamelCase			(       self	: Any )						->			List[Any]:
      a__		,a__  		=  self.model_tester.prepare_config_and_inputs_for_common()

      for backbone_class in self.all_model_classes:
        a__  		=  backbone_class(lowerCAmelCase )

        self.assertTrue(hasattr(lowerCAmelCase   ,   "backbone_type" ) )
        self.assertTrue(hasattr(lowerCAmelCase   ,   "stage_names" ) )
        self.assertTrue(hasattr(lowerCAmelCase   ,   "num_features" ) )
        self.assertTrue(hasattr(lowerCAmelCase   ,   "out_indices" ) )
        self.assertTrue(hasattr(lowerCAmelCase   ,   "out_features" ) )
        self.assertTrue(hasattr(lowerCAmelCase   ,   "out_feature_channels" ) )
        self.assertTrue(hasattr(lowerCAmelCase   ,   "channels" ) )

        self.assertIsInstance(backbone.backbone_type   ,   lowerCAmelCase )
        # Verify num_features has been initialized in the backbone init
        self.assertIsNotNone(backbone.num_features )
        self.assertTrue(len(backbone.channels ) == len(backbone.out_indices ) )
        self.assertTrue(len(backbone.stage_names ) == len(backbone.num_features ) )
        self.assertTrue(len(backbone.channels ) <= len(backbone.num_features ) )
        self.assertTrue(len(backbone.out_feature_channels ) == len(backbone.stage_names ) )




    def     __lowerCamelCase			(       self	: int )						->			Optional[int]:
      a__		,a__  		=  self.model_tester.prepare_config_and_inputs_for_common()
      a__  		=  inputs_dict["pixel_values"].shape[0]

      for backbone_class in self.all_model_classes:
        a__  		=  backbone_class(lowerCAmelCase )
        backbone.to(lowerCAmelCase )
        backbone.eval()

        a__  		=  backbone(**lowerCAmelCase )

        # Test default outputs and verify feature maps
        self.assertIsInstance(outputs.feature_maps   ,   lowerCAmelCase )
        self.assertTrue(len(outputs.feature_maps ) == len(backbone.channels ) )
        for feature_map, n_channels in zip(outputs.feature_maps   ,   backbone.channels ):
          self.assertTrue(feature_map.shape[:2]   ,   (batch_size, n_channels) )
        self.assertIsNone(outputs.hidden_states )
        self.assertIsNone(outputs.attentions )

        # Test output_hidden_states=True
        a__  		=  backbone(**lowerCAmelCase   ,   output_hidden_states=lowerCAmelCase )
        self.assertIsNotNone(outputs.hidden_states )
        self.assertTrue(len(outputs.hidden_states )   ,   len(backbone.stage_names ) )
        for hidden_state, n_channels in zip(outputs.hidden_states   ,   backbone.channels ):
          self.assertTrue(hidden_state.shape[:2]   ,   (batch_size, n_channels) )

        # Test output_attentions=True
        if self.has_attentions:
          a__  		=  backbone(**lowerCAmelCase   ,   output_attentions=lowerCAmelCase )
          self.assertIsNotNone(outputs.attentions )


import math
def 					__lowercase						(    lowerCamelCase__       )					->bool:

  '''simple docstring'''




  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(lowerCamelCase__       ) + 1       )			,					6       ):
    if number % i == 0 or number % (i + 2) == 0:
      return False
  return True
def 					__lowercase						(    lowerCamelCase__ = 2_00_00_00       )					->int:

  '''simple docstring'''




  return sum(num for num in range(3			,					lowerCamelCase__			,					2       ) if is_prime(lowerCamelCase__       )       ) + 2 if n > 2 else 0


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

