


from pickle import UnpicklingError

import jax
import jax.numpy as jnp
import numpy as np
from flax.serialization import from_bytes
from flax.traverse_util import flatten_dict

from ..utils import logging


lowerCAmelCase				:Dict        =      logging.get_logger(__name__)





def lowerCamelCase      (      lowerCAmelCase    :     Optional[int]		,		lowerCAmelCase    :     List[str]		):





	"""simple docstring"""







	try:
		with open(lowerCAmelCase		,		'rb'		) as flax_state_f:
			__magic_name__	:   Optional[int]					     =					from_bytes(lowerCAmelCase		,		flax_state_f.read()		)
	except UnpicklingError as e:
		try:
			with open(lowerCAmelCase		) as f:
				if f.read().startswith('version'		):
					raise OSError(
					    'You seem to have cloned a repository without having git-lfs installed. Please'
					    ' install git-lfs and run `git lfs install` followed by `git lfs pull` in the'
					    ' folder you cloned.'		)
				else:
					raise ValueError from e
		except (UnicodeDecodeError, ValueError):
			raise EnvironmentError(f'Unable to convert {model_file} to Flax deserializable object. '		)

	return load_flax_weights_in_pytorch_model(lowerCAmelCase		,		lowerCAmelCase		)





def lowerCamelCase      (      lowerCAmelCase    :     List[str]		,		lowerCAmelCase    :     Union[str, Any]		):





	"""simple docstring"""







	try:
		import torch  # noqa: F401
	except ImportError:
		logger.error(
		    'Loading Flax weights in PyTorch requires both PyTorch and Flax to be installed. Please see'
		    ' https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation'
		    ' instructions.'		)
		raise

	# check if we have bf16 weights
	__magic_name__	:   Dict					     =					flatten_dict(jax.tree_util.tree_map(lambda lowerCAmelCase		: x.dtype == jnp.bfloataa		,		lowerCAmelCase		)		).values()
	if any(lowerCAmelCase		):
		# convert all weights to fp32 if they are bf16 since torch.from_numpy can-not handle bf16

		# and bf16 is not fully supported in PT yet.
		logger.warning(
		    'Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` '
		    'before loading those in PyTorch model.'		)
		__magic_name__	:   Dict					     =					jax.tree_util.tree_map(
		    lambda lowerCAmelCase		: params.astype(np.floataa		) if params.dtype == jnp.bfloataa else params		,		lowerCAmelCase		)

	__magic_name__	:   Any					     =					''''''

	__magic_name__	:   List[Any]					     =					flatten_dict(lowerCAmelCase		,		sep='.'		)
	__magic_name__	:   List[Any]					     =					pt_model.state_dict()

	# keep track of unexpected & missing keys
	__magic_name__	:   List[str]					     =					[]
	__magic_name__	:   str					     =					set(pt_model_dict.keys()		)

	for flax_key_tuple, flax_tensor in flax_state_dict.items():
		__magic_name__	:   Tuple					     =					flax_key_tuple.split('.'		)

		if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:
			__magic_name__	:   Dict					     =					flax_key_tuple_array[:-1] + ['''weight''']
			__magic_name__	:   Any					     =					jnp.transpose(lowerCAmelCase		,		(3, 2, 0, 1)		)
		elif flax_key_tuple_array[-1] == "kernel":
			__magic_name__	:   Any					     =					flax_key_tuple_array[:-1] + ['''weight''']
			__magic_name__	:   str					     =					flax_tensor.T
		elif flax_key_tuple_array[-1] == "scale":
			__magic_name__	:   Union[str, Any]					     =					flax_key_tuple_array[:-1] + ['''weight''']

		if "time_embedding" not in flax_key_tuple_array:
			for i, flax_key_tuple_string in enumerate(lowerCAmelCase		):
				__magic_name__	:   Any					     =					(
				    flax_key_tuple_string.replace('_0'		,		'.0'		)
				    .replace('_1'		,		'.1'		)
				    .replace('_2'		,		'.2'		)
				    .replace('_3'		,		'.3'		)
				    .replace('_4'		,		'.4'		)
				    .replace('_5'		,		'.5'		)
				    .replace('_6'		,		'.6'		)
				    .replace('_7'		,		'.7'		)
				    .replace('_8'		,		'.8'		)
				    .replace('_9'		,		'.9'		)
				)

		__magic_name__	:   str					     =					'''.'''.join(lowerCAmelCase		)

		if flax_key in pt_model_dict:
			if flax_tensor.shape != pt_model_dict[flax_key].shape:
				raise ValueError(
				    f'Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected '
				    f'to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}.'		)
			else:
				# add weight to pytorch dict
				__magic_name__	:   int					     =					np.asarray(lowerCAmelCase		) if not isinstance(lowerCAmelCase		,		np.ndarray		) else flax_tensor
				__magic_name__	:   Tuple					     =					torch.from_numpy(lowerCAmelCase		)
				# remove from missing keys
				missing_keys.remove(lowerCAmelCase		)
		else:
			# weight is not expected by PyTorch model
			unexpected_keys.append(lowerCAmelCase		)

	pt_model.load_state_dict(lowerCAmelCase		)

	# re-transform missing_keys to list
	__magic_name__	:   int					     =					list(lowerCAmelCase		)

	if len(lowerCAmelCase		) > 0:
		logger.warning(
		    'Some weights of the Flax model were not used when initializing the PyTorch model'
		    f' {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing'
		    f' {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture'
		    ' (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This'
		    f' IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect'
		    ' to be exactly identical (e.g. initializing a BertForSequenceClassification model from a'
		    ' FlaxBertForSequenceClassification model).'		)
	if len(lowerCAmelCase		) > 0:
		logger.warning(
		    f'Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly'
		    f' initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to'
		    ' use it for predictions and inference.'		)

	return pt_model



'''simple docstring'''

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase				:Any        =      logging.get_logger(__name__)

lowerCAmelCase				:int        =      {
    '''unc-nlp/lxmert-base-uncased''': '''https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/config.json''',
}
class _lowerCamelCase	(						lowercase__							):



		'''simple docstring'''







		A_     :      List[str]				   =    """lxmert"""
		A_     :      int				   =    {}







		def __init__( self		:						int  ,					_A		:						List[Any]=30522  ,					_A		:						int=768  ,					_A		:						Any=12  ,					_A		:						Optional[Any]=9500  ,					_A		:						Any=1600  ,					_A		:						Tuple=400  ,					_A		:						str=3072  ,					_A		:						Tuple="gelu"  ,					_A		:						int=0.1  ,					_A		:						List[Any]=0.1  ,					_A		:						Dict=512  ,					_A		:						Dict=2  ,					_A		:						Tuple=0.02  ,					_A		:						List[Any]=1E-12  ,					_A		:						Optional[Any]=9  ,					_A		:						List[Any]=5  ,					_A		:						str=5  ,					_A		:						int=2048  ,					_A		:						Tuple=4  ,					_A		:						Tuple=6.67  ,					_A		:						Dict=True  ,					_A		:						str=True  ,					_A		:						str=True  ,					_A		:						Dict=True  ,					_A		:						str=True  ,					_A		:						int=True  ,					_A		:						Tuple=True  ,					**_A		:						int  ,					)  ->			str:
			__magic_name__	:   List[Any]					     =					vocab_size
			__magic_name__	:   List[Any]					     =					hidden_size
			__magic_name__	:   Optional[int]					     =					num_attention_heads
			__magic_name__	:   Dict					     =					hidden_act
			__magic_name__	:   Optional[Any]					     =					intermediate_size
			__magic_name__	:   str					     =					hidden_dropout_prob
			__magic_name__	:   List[str]					     =					attention_probs_dropout_prob
			__magic_name__	:   Tuple					     =					max_position_embeddings
			__magic_name__	:   Dict					     =					type_vocab_size
			__magic_name__	:   str					     =					initializer_range
			__magic_name__	:   str					     =					layer_norm_eps
			__magic_name__	:   Union[str, Any]					     =					num_qa_labels
			__magic_name__	:   str					     =					num_object_labels
			__magic_name__	:   List[str]					     =					num_attr_labels
			__magic_name__	:   Tuple					     =					l_layers
			__magic_name__	:   List[Any]					     =					x_layers
			__magic_name__	:   Optional[int]					     =					r_layers
			__magic_name__	:   Dict					     =					visual_feat_dim
			__magic_name__	:   Optional[int]					     =					visual_pos_dim
			__magic_name__	:   Optional[int]					     =					visual_loss_normalizer
			__magic_name__	:   int					     =					task_matched
			__magic_name__	:   Dict					     =					task_mask_lm
			__magic_name__	:   List[Any]					     =					task_obj_predict
			__magic_name__	:   str					     =					task_qa
			__magic_name__	:   List[Any]					     =					visual_obj_loss
			__magic_name__	:   Dict					     =					visual_attr_loss
			__magic_name__	:   int					     =					visual_feat_loss
			__magic_name__	:   Tuple					     =					{'vision': r_layers, 'cross_encoder': x_layers, 'language': l_layers}
			super().__init__(**_A      )