



'''simple docstring'''




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							:List[str]       = logging.get_logger(__name__)



def      a      (			lowerCamelCase__						,				lowerCamelCase__   ):
			'''simple docstring'''





			try:
						with open(lowerCamelCase__						,				"""rb"""   ) as flax_state_f:
									A_     :						str     =					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      a      (			lowerCamelCase__						,				lowerCamelCase__   ):
			'''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
			A_     :						Union[str, Any]     =					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."""   )
						A_     :						List[str]     =					jax.tree_util.tree_map(
						    lambda lowerCamelCase__   : params.astype(np.floataa   ) if params.dtype == jnp.bfloataa else params						,				lowerCamelCase__   )

			A_     :						List[str]     =					""""""

			A_     :						List[Any]     =					flatten_dict(lowerCamelCase__						,				sep="""."""   )
			A_     :						Optional[Any]     =					pt_model.state_dict()

			# keep track of unexpected & missing keys
			A_     :						str     =					[]
			A_     :						Optional[Any]     =					set(pt_model_dict.keys()   )

			for flax_key_tuple, flax_tensor in flax_state_dict.items():
						A_     :						List[str]     =					flax_key_tuple.split("""."""   )

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

						if "time_embedding" not in flax_key_tuple_array:
									for i, flax_key_tuple_string in enumerate(lowerCamelCase__   ):
												A_     :						str     =					(
												    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"""   )
												)

						A_     :						List[Any]     =					""".""".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
												A_     :						Optional[Any]     =					np.asarray(lowerCamelCase__   ) if not isinstance(lowerCamelCase__						,				np.ndarray   ) else flax_tensor
												A_     :						Any     =					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
			A_     :						List[str]     =					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'''




import warnings
from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import TensorType, is_torch_available, logging


lowerCamelCase							:Dict       = logging.get_logger(__name__)

lowerCamelCase							:Any       = {
    '''facebook/bart-large''': '''https://huggingface.co/facebook/bart-large/resolve/main/config.json''',
    # See all BART models at https://huggingface.co/models?filter=bart
}







class      _lowerCAmelCase							(      __UpperCAmelCase			):
	__SCREAMING_SNAKE_CASE       :		List[Any]		      = 'bart'
	__SCREAMING_SNAKE_CASE       :		Union[str, Any]		      = ['past_key_values']
	__SCREAMING_SNAKE_CASE       :		Dict		      = {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}


	def __init__(self	,				lowercase=50265	,				lowercase=1024	,				lowercase=12	,				lowercase=4096	,				lowercase=16	,				lowercase=12	,				lowercase=4096	,				lowercase=16	,				lowercase=0.0	,				lowercase=0.0	,				lowercase="gelu"	,				lowercase=1024	,				lowercase=0.1	,				lowercase=0.0	,				lowercase=0.0	,				lowercase=0.02	,				lowercase=0.0	,				lowercase=False	,				lowercase=True	,				lowercase=3	,				lowercase=1	,				lowercase=0	,				lowercase=2	,				lowercase=True	,				lowercase=2	,				lowercase=2	,				**lowercase	,				):
				A_     :						Optional[int]     =					vocab_size
				A_     :						Dict     =					max_position_embeddings
				A_     :						Dict     =					d_model
				A_     :						Any     =					encoder_ffn_dim
				A_     :						Dict     =					encoder_layers
				A_     :						Optional[int]     =					encoder_attention_heads
				A_     :						Tuple     =					decoder_ffn_dim
				A_     :						List[str]     =					decoder_layers
				A_     :						int     =					decoder_attention_heads
				A_     :						Dict     =					dropout
				A_     :						List[str]     =					attention_dropout
				A_     :						int     =					activation_dropout
				A_     :						Dict     =					activation_function
				A_     :						List[Any]     =					init_std
				A_     :						Dict     =					encoder_layerdrop
				A_     :						Tuple     =					decoder_layerdrop
				A_     :						Optional[int]     =					classifier_dropout
				A_     :						Union[str, Any]     =					use_cache
				A_     :						Dict     =					encoder_layers
				A_     :						Dict     =					scale_embedding  # scale factor will be sqrt(d_model) if True

				super().__init__(
				    num_labels=lowercase	,				pad_token_id=lowercase	,				bos_token_id=lowercase	,				eos_token_id=lowercase	,				is_encoder_decoder=lowercase	,				decoder_start_token_id=lowercase	,				forced_eos_token_id=lowercase	,				**lowercase	,				)

				# ensure backward compatibility for BART CNN models
				if self.forced_bos_token_id is None and kwargs.get("""force_bos_token_to_be_generated"""	,				lowercase							):
							A_     :						List[str]     =					self.bos_token_id
							warnings.warn(
							    F'Please make sure the config includes `forced_bos_token_id={self.bos_token_id}` in future versions. '
							    """The config can simply be saved and uploaded again to be fixed."""							)







class      _lowerCAmelCase							(      __UpperCAmelCase			):


	@property
	def    _a     (self							):
				if self.task in ["default", "seq2seq-lm"]:
							A_     :						List[Any]     =					OrderedDict(
							    [
							        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
							        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
							    ]							)

							if self.use_past:
										A_     :						Union[str, Any]     =					{0: """batch"""}
										A_     :						List[Any]     =					{0: """batch""", 1: """past_decoder_sequence + sequence"""}
							else:
										A_     :						Optional[int]     =					{0: """batch""", 1: """decoder_sequence"""}
										A_     :						List[str]     =					{0: """batch""", 1: """decoder_sequence"""}

							if self.use_past:
										self.fill_with_past_key_values_(lowercase	,				direction="""inputs"""							)
				elif self.task == "causal-lm":
							# TODO: figure this case out.
							A_     :						List[Any]     =					OrderedDict(
							    [
							        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
							        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
							    ]							)
							if self.use_past:
										A_,   A_     :						Optional[int]     =					self.num_layers
										for i in range(lowercase							):
													A_     :						List[str]     =					{0: """batch""", 2: """past_sequence + sequence"""}
													A_     :						List[str]     =					{0: """batch""", 2: """past_sequence + sequence"""}
				else:
							A_     :						Union[str, Any]     =					OrderedDict(
							    [
							        ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
							        ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
							        ("""decoder_input_ids""", {0: """batch""", 1: """decoder_sequence"""}),
							        ("""decoder_attention_mask""", {0: """batch""", 1: """decoder_sequence"""}),
							    ]							)

				return common_inputs


	@property
	def    _a     (self							):
				if self.task in ["default", "seq2seq-lm"]:
							A_     :						int     =					super().outputs
				else:
							A_     :						int     =					super(lowercase	,				self							).outputs
							if self.use_past:
										A_,   A_     :						Union[str, Any]     =					self.num_layers
										for i in range(lowercase							):
													A_     :						List[str]     =					{0: """batch""", 2: """past_sequence + sequence"""}
													A_     :						Optional[int]     =					{0: """batch""", 2: """past_sequence + sequence"""}
				return common_outputs


	def    _a     (self	,				lowercase	,				lowercase = -1	,				lowercase = -1	,				lowercase = False	,				lowercase = None	,				):
				A_     :						Optional[int]     =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
				    lowercase	,				lowercase	,				lowercase	,				lowercase	,				lowercase							)

				# Generate decoder inputs
				A_     :						int     =					seq_length if not self.use_past else 1
				A_     :						int     =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
				    lowercase	,				lowercase	,				lowercase	,				lowercase	,				lowercase							)
				A_     :						Optional[int]     =					{F'decoder_{name}': tensor for name, tensor in decoder_inputs.items()}
				A_     :						Dict     =					dict(**lowercase	,				**lowercase							)

				if self.use_past:
							if not is_torch_available():
										raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""							)
							else:
										import torch
							A_,   A_     :						Union[str, Any]     =					common_inputs["""input_ids"""].shape
							A_     :						Optional[Any]     =					common_inputs["""decoder_input_ids"""].shape[1]
							A_,   A_     :						str     =					self.num_attention_heads
							A_     :						Tuple     =					(
							    batch,
							    num_encoder_attention_heads,
							    encoder_seq_length,
							    self._config.hidden_size // num_encoder_attention_heads,
							)
							A_     :						Tuple     =					decoder_seq_length + 3
							A_     :						Tuple     =					(
							    batch,
							    num_decoder_attention_heads,
							    decoder_past_length,
							    self._config.hidden_size // num_decoder_attention_heads,
							)

							A_     :						List[str]     =					torch.cat(
							    [common_inputs["""decoder_attention_mask"""], torch.ones(lowercase	,				lowercase							)]	,				dim=1							)

							A_     :						Union[str, Any]     =					[]
							# If the number of encoder and decoder layers are present in the model configuration, both are considered
							A_,   A_     :						Optional[int]     =					self.num_layers
							A_     :						List[Any]     =					min(lowercase	,				lowercase							)
							A_     :						Tuple     =					max(lowercase	,				lowercase							) - min_num_layers
							A_     :						List[str]     =					"""encoder""" if num_encoder_layers > num_decoder_layers else """decoder"""

							for _ in range(lowercase							):
										common_inputs["past_key_values"].append(
										    (
										        torch.zeros(lowercase							),
										        torch.zeros(lowercase							),
										        torch.zeros(lowercase							),
										        torch.zeros(lowercase							),
										    )							)
							# TODO: test this.
							A_     :						List[Any]     =					encoder_shape if remaining_side_name == """encoder""" else decoder_shape
							for _ in range(lowercase	,				lowercase							):
										common_inputs["past_key_values"].append((torch.zeros(lowercase							), torch.zeros(lowercase							))							)
				return common_inputs


	def    _a     (self	,				lowercase	,				lowercase = -1	,				lowercase = -1	,				lowercase = False	,				lowercase = None	,				):
				A_     :						Dict     =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
				    lowercase	,				lowercase	,				lowercase	,				lowercase	,				lowercase							)

				if self.use_past:
							if not is_torch_available():
										raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""							)
							else:
										import torch
							A_,   A_     :						List[str]     =					common_inputs["""input_ids"""].shape
							# Not using the same length for past_key_values
							A_     :						Optional[Any]     =					seqlen + 2
							A_,   A_     :						str     =					self.num_layers
							A_,   A_     :						Optional[int]     =					self.num_attention_heads
							A_     :						str     =					(
							    batch,
							    num_encoder_attention_heads,
							    past_key_values_length,
							    self._config.hidden_size // num_encoder_attention_heads,
							)

							A_     :						Union[str, Any]     =					common_inputs["""attention_mask"""].dtype
							A_     :						int     =					torch.cat(
							    [common_inputs["""attention_mask"""], torch.ones(lowercase	,				lowercase	,				dtype=lowercase							)]	,				dim=1							)
							A_     :						int     =					[
							    (torch.zeros(lowercase							), torch.zeros(lowercase							)) for _ in range(lowercase							)
							]
				return common_inputs


	def    _a     (self	,				lowercase	,				lowercase = -1	,				lowercase = -1	,				lowercase = False	,				lowercase = None	,				):
				# Copied from OnnxConfig.generate_dummy_inputs
				# Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
				# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
				A_     :						List[Any]     =					compute_effective_axis_dimension(
				    lowercase	,				fixed_dimension=OnnxConfig.default_fixed_batch	,				num_token_to_add=0							)

				# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
				A_     :						Union[str, Any]     =					tokenizer.num_special_tokens_to_add(lowercase							)
				A_     :						List[Any]     =					compute_effective_axis_dimension(
				    lowercase	,				fixed_dimension=OnnxConfig.default_fixed_sequence	,				num_token_to_add=lowercase							)

				# Generate dummy inputs according to compute batch and sequence
				A_     :						str     =					[""" """.join([tokenizer.unk_token]							) * seq_length] * batch_size
				A_     :						Tuple     =					dict(tokenizer(lowercase	,				return_tensors=lowercase							)							)
				return common_inputs


	def    _a     (self	,				lowercase	,				lowercase = -1	,				lowercase = -1	,				lowercase = False	,				lowercase = None	,				):
				if self.task in ["default", "seq2seq-lm"]:
							A_     :						Union[str, Any]     =					self._generate_dummy_inputs_for_default_and_seqaseq_lm(
							    lowercase	,				batch_size=lowercase	,				seq_length=lowercase	,				is_pair=lowercase	,				framework=lowercase							)

				elif self.task == "causal-lm":
							A_     :						List[str]     =					self._generate_dummy_inputs_for_causal_lm(
							    lowercase	,				batch_size=lowercase	,				seq_length=lowercase	,				is_pair=lowercase	,				framework=lowercase							)
				else:
							A_     :						Optional[Any]     =					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
							    lowercase	,				batch_size=lowercase	,				seq_length=lowercase	,				is_pair=lowercase	,				framework=lowercase							)

				return common_inputs


	def    _a     (self	,				lowercase	,				lowercase	,				lowercase	,				lowercase							):
				if self.task in ["default", "seq2seq-lm"]:
							A_     :						Optional[Any]     =					super()._flatten_past_key_values_(lowercase	,				lowercase	,				lowercase	,				lowercase							)
				else:
							A_     :						List[Any]     =					super(lowercase	,				self							)._flatten_past_key_values_(
							    lowercase	,				lowercase	,				lowercase	,				lowercase							)