


'''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


_lowercase      :      Optional[int]            =					logging.get_logger(__name__)


def 				lowerCamelCase__				(	A       :      Optional[Any]				,       A       :      Optional[Any]					):




						'''simple docstring'''






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




def 				lowerCamelCase__				(	A       :      Optional[Any]				,       A       :      Optional[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
						UpperCAmelCase					    =     flatten_dict(jax.tree_util.tree_map(lambda A					: x.dtype == jnp.bfloataa				,       A					)					).values()
						if any(A					):
												# 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.'''					)
												UpperCAmelCase					    =     jax.tree_util.tree_map(
												    lambda A					: params.astype(np.floataa					) if params.dtype == jnp.bfloataa else params				,       A					)

						UpperCAmelCase					    =     ''''''

						UpperCAmelCase					    =     flatten_dict(A				,       sep='''.'''					)
						UpperCAmelCase					    =     pt_model.state_dict()

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

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

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

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

												UpperCAmelCase					    =     '''.'''.join(A					)

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

						pt_model.load_state_dict(A					)

						# re-transform missing_keys to list
						UpperCAmelCase					    =     list(A					)

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



def 				lowerCamelCase__				(	A       :      int				,       A       :      int					):




						'''simple docstring'''






						while a != 0:
												UpperCAmelCase    ,    UpperCAmelCase					    =     b % a, a
						return b




def 				lowerCamelCase__				(	A       :      int				,       A       :      int					):




						'''simple docstring'''






						if gcd(A				,       A					) != 1:
												UpperCAmelCase					    =     f"""mod inverse of {a!r} and {m!r} does not exist"""
												raise ValueError(A					)
						UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase					    =     1, 0, a
						UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase					    =     0, 1, m
						while va != 0:
												UpperCAmelCase					    =     ua // va
												UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase    ,    UpperCAmelCase					    =     (ua - q * va), (ua - q * va), (ua - q * va), va, va, va
						return ua % m





