



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


_snake_case	=						logging.get_logger(__name__)






def        A       (      _lowerCamelCase       ,				_lowerCamelCase						):





       '''simple docstring'''




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

       _lowerCAmelCase  :							Tuple				     =					""

       _lowerCAmelCase  :							Tuple				     =					flatten_dict(_lowerCamelCase       ,				sep="."						)
       _lowerCAmelCase  :							Any				     =					pt_model.state_dict()

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

       for flax_key_tuple, flax_tensor in flax_state_dict.items():
              _lowerCAmelCase  :							int				     =					flax_key_tuple.split("."						)

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

              if "time_embedding" not in flax_key_tuple_array:
                     for i, flax_key_tuple_string in enumerate(_lowerCamelCase						):
                            _lowerCAmelCase  :							Optional[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"						)
                            )

              _lowerCAmelCase  :							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
                            _lowerCAmelCase  :							int				     =					np.asarray(_lowerCamelCase						) if not isinstance(_lowerCamelCase       ,				np.ndarray						) else flax_tensor
                            _lowerCAmelCase  :							Optional[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
       _lowerCAmelCase  :							Any				     =					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





def        A       (      _lowerCamelCase						):





							'''simple docstring'''




							if length <= 0 or not isinstance(_lowerCamelCase       ,				_lowerCamelCase						):
														raise ValueError("Length must be a positive integer."						)
							return [n * (2 * n - 1) for n in range(_lowerCamelCase						)]


if __name__ == "__main__":
						print(hexagonal_numbers(length=5))
						print(hexagonal_numbers(length=10))
