
"""simple docstring"""

import argparse
import collections
from pathlib import Path

import torch
from torch.serialization import default_restore_location

from transformers import BertConfig, DPRConfig, DPRContextEncoder, DPRQuestionEncoder, DPRReader


UpperCamelCase      :							Dict          =					collections.namedtuple(
    "CheckpointState", ["model_dict", "optimizer_dict", "scheduler_dict", "offset", "epoch", "encoder_params"]
)






def 				A		(							snake_case :Dict						) ->      int:
 print(f'Reading saved model from {model_file}'						)
 __UpperCamelCase							    =			torch.load(UpperCamelCase__							,   map_location=lambda snake_case							,   snake_case						: default_restore_location(UpperCamelCase__							,   'cpu'						)						)
 return CheckpointState(**UpperCamelCase__						)

class __lowerCAmelCase						:





     def __init__(      self      ,	__UpperCAmelCase ):

      '''simple docstring'''




      __UpperCamelCase							    =			src_file





     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      raise NotImplementedError







     @staticmethod
     def 		UpperCAmelCase   (      __UpperCAmelCase      ,	*__UpperCAmelCase      ,	**__UpperCAmelCase ):

      '''simple docstring'''




      if comp_type.startswith('c' ):
       return DPRContextEncoderState(*__UpperCAmelCase      ,	**__UpperCAmelCase )
      if comp_type.startswith('q' ):
       return DPRQuestionEncoderState(*__UpperCAmelCase      ,	**__UpperCAmelCase )
      if comp_type.startswith('r' ):
       return DPRReaderState(*__UpperCAmelCase      ,	**__UpperCAmelCase )
      else:
       raise ValueError('Component type must be either \'ctx_encoder\', \'question_encoder\' or \'reader\'.' )


class __lowerCAmelCase						( __A     ):





     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      __UpperCamelCase							    =			DPRContextEncoder(DPRConfig(**BertConfig.get_config_dict('bert-base-uncased' )[0] ) )
      print(F'Loading DPR biencoder from {self.src_file}' )
      __UpperCamelCase							    =			load_states_from_checkpoint(self.src_file )
      __UpperCamelCase    ,      __UpperCamelCase							    =			model.ctx_encoder, 'ctx_model.'
      # Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
      __UpperCamelCase							    =			{'bert_model.embeddings.position_ids': model.ctx_encoder.bert_model.embeddings.position_ids}
      for key, value in saved_state.model_dict.items():
       if key.startswith(__UpperCAmelCase ):
        __UpperCamelCase							    =			key[len(__UpperCAmelCase ) :]
        if not key.startswith('encode_proj.' ):
         __UpperCamelCase							    =			'bert_model.' + key
        __UpperCamelCase							    =			value
      encoder.load_state_dict(__UpperCAmelCase )
      return model


class __lowerCAmelCase						( __A     ):





     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      __UpperCamelCase							    =			DPRQuestionEncoder(DPRConfig(**BertConfig.get_config_dict('bert-base-uncased' )[0] ) )
      print(F'Loading DPR biencoder from {self.src_file}' )
      __UpperCamelCase							    =			load_states_from_checkpoint(self.src_file )
      __UpperCamelCase    ,      __UpperCamelCase							    =			model.question_encoder, 'question_model.'
      # Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
      __UpperCamelCase							    =			{'bert_model.embeddings.position_ids': model.question_encoder.bert_model.embeddings.position_ids}
      for key, value in saved_state.model_dict.items():
       if key.startswith(__UpperCAmelCase ):
        __UpperCamelCase							    =			key[len(__UpperCAmelCase ) :]
        if not key.startswith('encode_proj.' ):
         __UpperCamelCase							    =			'bert_model.' + key
        __UpperCamelCase							    =			value
      encoder.load_state_dict(__UpperCAmelCase )
      return model


class __lowerCAmelCase						( __A     ):





     def 		UpperCAmelCase   (      self ):

      '''simple docstring'''




      __UpperCamelCase							    =			DPRReader(DPRConfig(**BertConfig.get_config_dict('bert-base-uncased' )[0] ) )
      print(F'Loading DPR reader from {self.src_file}' )
      __UpperCamelCase							    =			load_states_from_checkpoint(self.src_file )
      # Fix changes from https://github.com/huggingface/transformers/commit/614fef1691edb806de976756d4948ecbcd0c0ca3
      __UpperCamelCase							    =			{
          'encoder.bert_model.embeddings.position_ids': model.span_predictor.encoder.bert_model.embeddings.position_ids
      }
      for key, value in saved_state.model_dict.items():
       if key.startswith('encoder.' ) and not key.startswith('encoder.encode_proj' ):
        __UpperCamelCase							    =			'encoder.bert_model.' + key[len('encoder.' ) :]
       __UpperCamelCase							    =			value
      model.span_predictor.load_state_dict(__UpperCAmelCase )
      return model






def 				A		(							snake_case :List[Any]							,   snake_case :Optional[int]							,   snake_case :Optional[Any]						) ->      Tuple:
 __UpperCamelCase							    =			Path(UpperCamelCase__						)
 dest_dir.mkdir(exist_ok=UpperCamelCase__						)

 __UpperCamelCase							    =			DPRState.from_type(UpperCamelCase__							,   src_file=UpperCamelCase__						)
 __UpperCamelCase							    =			dpr_state.load_dpr_model()
 model.save_pretrained(UpperCamelCase__						)
 model.from_pretrained(UpperCamelCase__						)  # sanity check


if __name__ == "__main__":
      UpperCamelCase      :							Tuple          =					argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          "--type", type=str, help="Type of the component to convert: 'ctx_encoder', 'question_encoder' or 'reader'."
      )
      parser.add_argument(
          "--src",
          type=str,
          help=(
              "Path to the dpr checkpoint file. They can be downloaded from the official DPR repo"
              " https://github.com/facebookresearch/DPR. Note that in the official repo, both encoders are stored in the"
              " 'retriever' checkpoints."
          ),
      )
      parser.add_argument("--dest", type=str, default=None, help="Path to the output PyTorch model directory.")
      UpperCamelCase      :							Any          =					parser.parse_args()

      UpperCamelCase      :							Optional[int]          =					Path(args.src)
      UpperCamelCase      :							List[Any]          =					f'''converted-{src_file.name}''' if args.dest is None else args.dest
      UpperCamelCase      :							Dict          =					Path(dest_dir)
      assert src_file.exists()
      assert (
          args.type is not None
      ), "Please specify the component type of the DPR model to convert: 'ctx_encoder', 'question_encoder' or 'reader'."
      convert(args.type, src_file, dest_dir)




"""simple docstring"""




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      UpperCamelCase__(      __A			):





						def 					snake_case__						(							self  )       ->					int:
													A__						  =				self.config_class(**self.inputs_dict  )
													self.parent.assertTrue(hasattr(__UpperCAmelCase		,'hidden_sizes'  )  )
													self.parent.assertTrue(hasattr(__UpperCAmelCase		,'num_encoder_blocks'  )  )






class      UpperCamelCase__:





						def __init__(							self		,__UpperCAmelCase		,__UpperCAmelCase=13		,__UpperCAmelCase=64		,__UpperCAmelCase=3		,__UpperCAmelCase=4		,__UpperCAmelCase=[2, 2, 2, 2]		,__UpperCAmelCase=[8, 4, 2, 1]		,__UpperCAmelCase=[16, 32, 64, 1_28]		,__UpperCAmelCase=[1, 4, 8, 16]		,__UpperCAmelCase=False		,__UpperCAmelCase=True		,__UpperCAmelCase="gelu"		,__UpperCAmelCase=0.1		,__UpperCAmelCase=0.0_2		,__UpperCAmelCase=3		,__UpperCAmelCase=None		,)       ->					Tuple:
													A__						  =				parent
													A__						  =				batch_size
													A__						  =				image_size
													A__						  =				num_channels
													A__						  =				num_encoder_blocks
													A__						  =				sr_ratios
													A__						  =				depths
													A__						  =				hidden_sizes
													A__						  =				downsampling_rates
													A__						  =				is_training
													A__						  =				use_labels
													A__						  =				hidden_act
													A__						  =				hidden_dropout_prob
													A__						  =				initializer_range
													A__						  =				num_labels
													A__						  =				scope





						def 					snake_case__						(							self  )       ->					Tuple:
													A__						  =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

													A__						  =				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 					snake_case__						(							self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase  )       ->					Union[str, Any]:
													A__						  =				PoolFormerModel(config=__UpperCAmelCase  )
													model.to(__UpperCAmelCase  )
													model.eval()
													A__						  =				model(__UpperCAmelCase  )
													A__						  =				A__						  =				self.image_size // 3_2.0
													self.parent.assertEqual(
													    result.last_hidden_state.shape		,(self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)  )





						def 					snake_case__						(							self  )       ->					Any:
													A__						  =				self.prepare_config_and_inputs()
													A__  ,	A__  ,	A__						  =				config_and_inputs
													A__						  =				{'pixel_values': pixel_values}
													return config, inputs_dict






@require_torch
class      UpperCamelCase__(      __A		,    __A		,    unittest.TestCase			):
						lowerCAmelCase__	:    Optional[int]    				=		(PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
						lowerCAmelCase__	:    Optional[Any]    				=		(
						    {'feature-extraction': PoolFormerModel, 'image-classification': PoolFormerForImageClassification}
						    if is_torch_available()
						    else {}
						)

						lowerCAmelCase__	:    Any    				=		False
						lowerCAmelCase__	:    str    				=		False
						lowerCAmelCase__	:    Any    				=		False
						lowerCAmelCase__	:    str    				=		False
						lowerCAmelCase__	:    Optional[int]    				=		False





						def 					snake_case__						(							self  )       ->					Any:
													A__						  =				PoolFormerModelTester(self  )
													A__						  =				PoolFormerConfigTester(self		,config_class=__UpperCAmelCase  )





						def 					snake_case__						(							self  )       ->					int:
													self.config_tester.run_common_tests()





						def 					snake_case__						(							self  )       ->					Tuple:
													A__						  =				self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*__UpperCAmelCase  )





						@unittest.skip('PoolFormer does not use inputs_embeds'  )
						def 					snake_case__						(							self  )       ->					int:
													pass





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





						def 					snake_case__						(							self  )       ->					List[Any]:
													def check_hidden_states_output(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase  ):
																				A__						  =				model_class(__UpperCAmelCase  )
																				model.to(__UpperCAmelCase  )
																				model.eval()

																				with torch.no_grad():
																											A__						  =				model(**self._prepare_for_class(__UpperCAmelCase		,__UpperCAmelCase  )  )

																				A__						  =				outputs.hidden_states

																				A__						  =				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,
																				    ]		,)

													A__  ,	A__						  =				self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				A__						  =				True
																				check_hidden_states_output(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase  )

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

																				check_hidden_states_output(__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase  )





						def 					snake_case__						(							self  )       ->					Union[str, Any]:
													if not self.model_tester.is_training:
																				return

													A__  ,	A__						  =				self.model_tester.prepare_config_and_inputs_for_common()
													A__						  =				True

													for model_class in self.all_model_classes:
																				if model_class in get_values(__UpperCAmelCase  ):
																											continue
																				A__						  =				model_class(__UpperCAmelCase  )
																				model.to(__UpperCAmelCase  )
																				model.train()
																				A__						  =				self._prepare_for_class(__UpperCAmelCase		,__UpperCAmelCase		,return_labels=__UpperCAmelCase  )
																				A__						  =				model(**__UpperCAmelCase  ).loss
																				loss.backward()





						def 					snake_case__						(							self  )       ->					Union[str, Any]:
													A__  ,	A__						  =				self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																				A__						  =				model_class(__UpperCAmelCase  )
																				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]		,__UpperCAmelCase  )





						@slow
						def 					snake_case__						(							self  )       ->					Union[str, Any]:
													for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				A__						  =				PoolFormerModel.from_pretrained(__UpperCAmelCase  )
																				self.assertIsNotNone(__UpperCAmelCase  )






def 	UpperCAmelCase       (						):






							"""simple docstring"""





							A__						  =				Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
							return image


@require_torch
class      UpperCamelCase__(      unittest.TestCase			):





						@slow
						def 					snake_case__						(							self  )       ->					Union[str, Any]:
													A__						  =				PoolFormerImageProcessor()
													A__						  =				PoolFormerForImageClassification.from_pretrained('sail/poolformer_s12'  ).to(__UpperCAmelCase  )

													A__						  =				image_processor(images=prepare_img()		,return_tensors='pt'  ).to(__UpperCAmelCase  )

													# forward pass
													with torch.no_grad():
																				A__						  =				model(**__UpperCAmelCase  )

													# verify the logits
													A__						  =				torch.Size((1, 10_00)  )
													self.assertEqual(outputs.logits.shape		,__UpperCAmelCase  )

													A__						  =				torch.tensor([-0.6_1_1_3, 0.1_6_8_5, -0.0_4_9_2]  ).to(__UpperCAmelCase  )
													self.assertTrue(torch.allclose(outputs.logits[0, :3]		,__UpperCAmelCase		,atol=1e-4  )  )





