





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


_A :   Any  			=  logging.get_logger(__name__)



def 	_a						(   UpperCAmelCase      ,  UpperCAmelCase					)    ->    int:







   """simple docstring"""
   try:
      with open(UpperCAmelCase_      ,  '''rb'''					) as flax_state_f:
         lowerCamelCase__       :						int        =							from_bytes(UpperCAmelCase_      ,  flax_state_f.read()					)
   except UnpicklingError as e:
      try:
         with open(UpperCAmelCase_					) 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(UpperCAmelCase_      ,  UpperCAmelCase_					)




def 	_a						(   UpperCAmelCase      ,  UpperCAmelCase					)    ->    Optional[int]:







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

   lowerCamelCase__       :						int        =							''''''

   lowerCamelCase__       :						Dict        =							flatten_dict(UpperCAmelCase_      ,  sep='''.'''					)
   lowerCamelCase__       :						Optional[int]        =							pt_model.state_dict()

   # keep track of unexpected & missing keys
   lowerCamelCase__       :						Union[str, Any]        =							[]
   lowerCamelCase__       :						Optional[Any]        =							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__       :						Optional[int]        =							flax_key_tuple_array[:-1] + ['''weight''']
         lowerCamelCase__       :						Tuple        =							jnp.transpose(UpperCAmelCase_      ,  (3, 2, 0, 1)					)
      elif flax_key_tuple_array[-1] == "kernel":
         lowerCamelCase__       :						List[str]        =							flax_key_tuple_array[:-1] + ['''weight''']
         lowerCamelCase__       :						int        =							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(UpperCAmelCase_					):
            lowerCamelCase__       :						int        =							(
                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__       :						Dict        =							'''.'''.join(UpperCAmelCase_					)

      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__       :						List[Any]        =							np.asarray(UpperCAmelCase_					) if not isinstance(UpperCAmelCase_      ,  np.ndarray					) else flax_tensor
            lowerCamelCase__       :						Tuple        =							torch.from_numpy(UpperCAmelCase_					)
            # remove from missing keys
            missing_keys.remove(UpperCAmelCase_					)
      else:
         # weight is not expected by PyTorch model
         unexpected_keys.append(UpperCAmelCase_					)

   pt_model.load_state_dict(UpperCAmelCase_					)

   # re-transform missing_keys to list
   lowerCamelCase__       :						List[Any]        =							list(UpperCAmelCase_					)

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













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


_A :   Any  			=  logging.get_logger(__name__)

_A :   int  			=  {
    'facebook/timesformer': 'https://huggingface.co/facebook/timesformer/resolve/main/config.json',
}


class        __SCREAMING_SNAKE_CASE      (			lowerCAmelCase_ ):
       _UpperCAmelCase				:  Dict			   =   "timesformer"







       def __init__(				self					:     List[str]		, A					:     int=2_2_4		, A					:     Optional[Any]=1_6		, A					:     str=3		, A					:     str=8		, A					:     Any=7_6_8		, A					:     Dict=1_2		, A					:     Optional[Any]=1_2		, A					:     Any=3_0_7_2		, A					:     str="gelu"		, A					:     Optional[int]=0.0		, A					:     Union[str, Any]=0.0		, A					:     List[Any]=0.02		, A					:     int=1e-6		, A					:     Tuple=True		, A					:     Any="divided_space_time"		, A					:     Optional[Any]=0		, **A					:     Tuple		, )       ->str:
          super().__init__(**A      )

          lowerCamelCase__       :						Optional[Any]        =							image_size
          lowerCamelCase__       :						int        =							patch_size
          lowerCamelCase__       :						Any        =							num_channels
          lowerCamelCase__       :						Optional[int]        =							num_frames

          lowerCamelCase__       :						Optional[Any]        =							hidden_size
          lowerCamelCase__       :						Optional[int]        =							num_hidden_layers
          lowerCamelCase__       :						Optional[int]        =							num_attention_heads
          lowerCamelCase__       :						Dict        =							intermediate_size
          lowerCamelCase__       :						Optional[Any]        =							hidden_act
          lowerCamelCase__       :						Union[str, Any]        =							hidden_dropout_prob
          lowerCamelCase__       :						Dict        =							attention_probs_dropout_prob
          lowerCamelCase__       :						List[Any]        =							initializer_range
          lowerCamelCase__       :						str        =							layer_norm_eps
          lowerCamelCase__       :						Union[str, Any]        =							qkv_bias

          lowerCamelCase__       :						str        =							attention_type
          lowerCamelCase__       :						List[str]        =							drop_path_rate



