


import math

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


lowerCAmelCase       =							logging.get_logger(__name__)

lowerCAmelCase       =							{
    'facebook/data2vec-base-960h': 'https://huggingface.co/facebook/data2vec-audio-base-960h/resolve/main/config.json',
    # See all Data2VecAudio models at https://huggingface.co/models?filter=data2vec-audio
}


class        _a							(			UpperCamelCase__			):
							_lowercase	:			Optional[int]        = '''data2vec-audio'''

							def __init__(							self:	Tuple    ,						UpperCamelCase_:	Dict=32    ,						UpperCamelCase_:	List[Any]=768    ,						UpperCamelCase_:	int=12    ,						UpperCamelCase_:	List[str]=12    ,						UpperCamelCase_:	str=3_072    ,						UpperCamelCase_:	str="gelu"    ,						UpperCamelCase_:	Any=0.1    ,						UpperCamelCase_:	int=0.1    ,						UpperCamelCase_:	Tuple=0.1    ,						UpperCamelCase_:	Union[str, Any]=0.0    ,						UpperCamelCase_:	str=0.1    ,						UpperCamelCase_:	Dict=0.1    ,						UpperCamelCase_:	List[str]=0.02    ,						UpperCamelCase_:	Dict=1E-5    ,						UpperCamelCase_:	str="gelu"    ,						UpperCamelCase_:	Union[str, Any]=(512, 512, 512, 512, 512, 512, 512)    ,						UpperCamelCase_:	str=(5, 2, 2, 2, 2, 2, 2)    ,						UpperCamelCase_:	Any=(10, 3, 3, 3, 3, 2, 2)    ,						UpperCamelCase_:	int=False    ,						UpperCamelCase_:	List[str]=16    ,						UpperCamelCase_:	List[str]=19    ,						UpperCamelCase_:	Optional[Any]=5    ,						UpperCamelCase_:	List[str]=0.05    ,						UpperCamelCase_:	List[str]=10    ,						UpperCamelCase_:	List[Any]=2    ,						UpperCamelCase_:	str=0.0    ,						UpperCamelCase_:	Dict=10    ,						UpperCamelCase_:	Optional[int]=0    ,						UpperCamelCase_:	int="sum"    ,						UpperCamelCase_:	Optional[Any]=False    ,						UpperCamelCase_:	Tuple=False    ,						UpperCamelCase_:	Dict=256    ,						UpperCamelCase_:	Optional[int]=(512, 512, 512, 512, 1_500)    ,						UpperCamelCase_:	Tuple=(5, 3, 3, 1, 1)    ,						UpperCamelCase_:	str=(1, 2, 3, 1, 1)    ,						UpperCamelCase_:	List[Any]=512    ,						UpperCamelCase_:	int=0    ,						UpperCamelCase_:	List[str]=1    ,						UpperCamelCase_:	str=2    ,						UpperCamelCase_:	int=False    ,						UpperCamelCase_:	Tuple=3    ,						UpperCamelCase_:	Any=2    ,						UpperCamelCase_:	Dict=3    ,						UpperCamelCase_:	str=None    ,						**UpperCamelCase_:	Optional[Any]    ,						)			->   Optional[Any]:





									"""simple docstring"""







									super().__init__(**UpperCamelCase_    ,						pad_token_id=UpperCamelCase_    ,						bos_token_id=UpperCamelCase_    ,						eos_token_id=UpperCamelCase_							)
									lowercase__            =      hidden_size
									lowercase__            =      feat_extract_activation
									lowercase__            =      list(UpperCamelCase_							)
									lowercase__            =      list(UpperCamelCase_							)
									lowercase__            =      list(UpperCamelCase_							)
									lowercase__            =      conv_bias
									lowercase__            =      num_conv_pos_embeddings
									lowercase__            =      num_conv_pos_embedding_groups
									lowercase__            =      conv_pos_kernel_size
									lowercase__            =      len(self.conv_dim							)
									lowercase__            =      num_hidden_layers
									lowercase__            =      intermediate_size
									lowercase__            =      hidden_act
									lowercase__            =      num_attention_heads
									lowercase__            =      hidden_dropout
									lowercase__            =      attention_dropout
									lowercase__            =      activation_dropout
									lowercase__            =      feat_proj_dropout
									lowercase__            =      final_dropout
									lowercase__            =      layerdrop
									lowercase__            =      layer_norm_eps
									lowercase__            =      initializer_range
									lowercase__            =      vocab_size
									lowercase__            =      use_weighted_layer_sum

									if (
									    (len(self.conv_stride							) != self.num_feat_extract_layers)
									    or (len(self.conv_kernel							) != self.num_feat_extract_layers)
									    or (len(self.conv_dim							) != self.num_feat_extract_layers)
									):
											raise ValueError(
											    '''Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =='''
											    ''' `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ='''
											    f' {len(self.conv_dim							)}`, `len(config.conv_stride) = {len(self.conv_stride							)}`,'
											    f' `len(config.conv_kernel) = {len(self.conv_kernel							)}`.'							)

									# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
									lowercase__            =      mask_time_prob
									lowercase__            =      mask_time_length
									lowercase__            =      mask_time_min_masks
									lowercase__            =      mask_feature_prob
									lowercase__            =      mask_feature_length
									lowercase__            =      mask_feature_min_masks

									# ctc loss
									lowercase__            =      ctc_loss_reduction
									lowercase__            =      ctc_zero_infinity

									# adapter
									lowercase__            =      add_adapter
									lowercase__            =      adapter_kernel_size
									lowercase__            =      adapter_stride
									lowercase__            =      num_adapter_layers
									lowercase__            =      output_hidden_size or hidden_size

									# SequenceClassification-specific parameter. Feel free to ignore for other classes.
									lowercase__            =      classifier_proj_size

									# XVector-specific parameters. Feel free to ignore for other classes.
									lowercase__            =      list(UpperCamelCase_							)
									lowercase__            =      list(UpperCamelCase_							)
									lowercase__            =      list(UpperCamelCase_							)
									lowercase__            =      xvector_output_dim


							@property
							def       lowerCamelCase_ (							self:	Union[str, Any]							)			->   Any:





									"""simple docstring"""







									return math.prod(self.conv_stride							)






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       =							logging.get_logger(__name__)
def 			_a (      SCREAMING_SNAKE_CASE						,				SCREAMING_SNAKE_CASE     ):


		"""simple docstring"""




		try:
				with open(SCREAMING_SNAKE_CASE						,				'''rb'''     ) as flax_state_f:
						lowercase__            =      from_bytes(SCREAMING_SNAKE_CASE						,				flax_state_f.read()     )
		except UnpicklingError as e:
				try:
						with open(SCREAMING_SNAKE_CASE     ) 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(SCREAMING_SNAKE_CASE						,				SCREAMING_SNAKE_CASE     )
def 			_a (      SCREAMING_SNAKE_CASE						,				SCREAMING_SNAKE_CASE     ):


		"""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
		lowercase__            =      flatten_dict(jax.tree_util.tree_map(lambda SCREAMING_SNAKE_CASE     : x.dtype == jnp.bfloataa						,				SCREAMING_SNAKE_CASE     )     ).values()
		if any(SCREAMING_SNAKE_CASE     ):
				# 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.'''     )
				lowercase__            =      jax.tree_util.tree_map(
				    lambda SCREAMING_SNAKE_CASE     : params.astype(np.floataa     ) if params.dtype == jnp.bfloataa else params						,				SCREAMING_SNAKE_CASE     )

		lowercase__            =      ''''''

		lowercase__            =      flatten_dict(SCREAMING_SNAKE_CASE						,				sep='''.'''     )
		lowercase__            =      pt_model.state_dict()

		# keep track of unexpected & missing keys
		lowercase__            =      []
		lowercase__            =      set(pt_model_dict.keys()     )

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

				if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:
						lowercase__            =      flax_key_tuple_array[:-1] + ['''weight''']
						lowercase__            =      jnp.transpose(SCREAMING_SNAKE_CASE						,				(3, 2, 0, 1)     )
				elif flax_key_tuple_array[-1] == "kernel":
						lowercase__            =      flax_key_tuple_array[:-1] + ['''weight''']
						lowercase__            =      flax_tensor.T
				elif flax_key_tuple_array[-1] == "scale":
						lowercase__            =      flax_key_tuple_array[:-1] + ['''weight''']

				if "time_embedding" not in flax_key_tuple_array:
						for i, flax_key_tuple_string in enumerate(SCREAMING_SNAKE_CASE     ):
								lowercase__            =      (
								    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'''     )
								)

				lowercase__            =      '''.'''.join(SCREAMING_SNAKE_CASE     )

				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
								lowercase__            =      np.asarray(SCREAMING_SNAKE_CASE     ) if not isinstance(SCREAMING_SNAKE_CASE						,				np.ndarray     ) else flax_tensor
								lowercase__            =      torch.from_numpy(SCREAMING_SNAKE_CASE     )
								# remove from missing keys
								missing_keys.remove(SCREAMING_SNAKE_CASE     )
				else:
						# weight is not expected by PyTorch model
						unexpected_keys.append(SCREAMING_SNAKE_CASE     )

		pt_model.load_state_dict(SCREAMING_SNAKE_CASE     )

		# re-transform missing_keys to list
		lowercase__            =      list(SCREAMING_SNAKE_CASE     )

		if len(SCREAMING_SNAKE_CASE     ) > 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(SCREAMING_SNAKE_CASE     ) > 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


