

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


SCREAMING_SNAKE_CASE_						=					logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_						=					{
    'google/reformer-crime-and-punishment': (
        'https://huggingface.co/google/reformer-crime-and-punishment/resolve/main/config.json'
    ),
    'google/reformer-enwik8': 'https://huggingface.co/google/reformer-enwik8/resolve/main/config.json',
}

class  a     (		UpperCAmelCase ):
						_lowercase			  =	"reformer"
						_lowercase			  =	["past_buckets_states"]
						_lowercase			  =	{}


						def __init__(				self  ,    A_=64  ,    A_=["local", "lsh", "local", "lsh", "local", "lsh"]  ,    A_=1.0  ,    A_=True  ,    A_=[64, 64]  ,    A_=[64, 192]  ,    A_=0  ,    A_=2  ,    A_=512  ,    A_=None  ,    A_="relu"  ,    A_=0.05  ,    A_=256  ,    A_=0.02  ,    A_=False  ,    A_=1e-12  ,    A_=1  ,    A_=0  ,    A_=0.05  ,    A_=64  ,    A_=64  ,    A_=0.0  ,    A_=1  ,    A_=0  ,    A_=4096  ,    A_=12  ,    A_=None  ,    A_=1  ,    A_=0  ,    A_=320  ,    A_=False  ,    A_=True  ,    A_=None  ,    **A_  ,    ):







										'''simple docstring'''


										_UpperCAmelCase				:						Dict       						=			hash_seed
										_UpperCAmelCase				:						List[str]       						=			vocab_size
										_UpperCAmelCase				:						List[str]       						=			attention_head_size
										_UpperCAmelCase				:						int       						=			hidden_size
										_UpperCAmelCase				:						List[str]       						=			num_attention_heads
										_UpperCAmelCase				:						str       						=			num_hashes
										_UpperCAmelCase				:						str       						=			len(A_		)
										_UpperCAmelCase				:						Optional[int]       						=			tuple(A_		) if isinstance(A_  ,    A_		) else num_buckets
										_UpperCAmelCase				:						Dict       						=			lsh_attn_chunk_length
										_UpperCAmelCase				:						str       						=			local_attn_chunk_length
										_UpperCAmelCase				:						Optional[Any]       						=			lsh_num_chunks_after
										_UpperCAmelCase				:						Any       						=			lsh_num_chunks_before
										_UpperCAmelCase				:						Tuple       						=			local_num_chunks_after
										_UpperCAmelCase				:						Union[str, Any]       						=			local_num_chunks_before
										_UpperCAmelCase				:						Optional[Any]       						=			hidden_act
										_UpperCAmelCase				:						List[Any]       						=			feed_forward_size
										_UpperCAmelCase				:						Optional[Any]       						=			hidden_dropout_prob
										_UpperCAmelCase				:						Dict       						=			lsh_attention_probs_dropout_prob
										_UpperCAmelCase				:						List[str]       						=			local_attention_probs_dropout_prob
										_UpperCAmelCase				:						Optional[int]       						=			max_position_embeddings
										_UpperCAmelCase				:						str       						=			initializer_range
										_UpperCAmelCase				:						Tuple       						=			layer_norm_eps
										_UpperCAmelCase				:						Optional[Any]       						=			axial_pos_embds
										_UpperCAmelCase				:						Optional[int]       						=			tuple(A_		)
										_UpperCAmelCase				:						List[Any]       						=			tuple(A_		)
										_UpperCAmelCase				:						Dict       						=			axial_norm_std
										_UpperCAmelCase				:						List[str]       						=			chunk_size_lm_head
										_UpperCAmelCase				:						List[str]       						=			attn_layers
										_UpperCAmelCase				:						Optional[Any]       						=			use_cache
										_UpperCAmelCase				:						int       						=			classifier_dropout
										super().__init__(
										    pad_token_id=A_  ,    eos_token_id=A_  ,    is_decoder=A_  ,    tie_word_embeddings=A_  ,    **A_  ,    )




'''simple docstring'''

from typing import Optional, Tuple

import flax.linen as nn
import jax
import jax.numpy as jnp
from configuration_hybrid_clip import HybridCLIPConfig
from flax.core.frozen_dict import FrozenDict

from transformers import FLAX_MODEL_MAPPING, FlaxCLIPVisionModel
from transformers.modeling_flax_utils import FlaxPreTrainedModel
from transformers.models.clip.modeling_flax_clip import FlaxCLIPOutput
from transformers.utils import logging


lowerCAmelCase_			:			List[str]			   =     logging.get_logger(__name__)







class 	__lowerCAmelCase    (  nn.Module				):
     snake_case   :    HybridCLIPConfig
     snake_case   :    jnp.dtype							      =      jnp.floataa



     def     snake_case_ (self	):
          _UpperCAmelCase					:  int         =    self.config.text_config
          _UpperCAmelCase					:  Dict         =    self.config.vision_config

          _UpperCAmelCase					:  str         =    self.config.projection_dim
          _UpperCAmelCase					:  int         =    text_config.hidden_size
          _UpperCAmelCase					:  int         =    vision_config.hidden_size

          _UpperCAmelCase					:  Optional[int]         =    FLAX_MODEL_MAPPING[self.config.text_config.__class__].module_class
          _UpperCAmelCase					:  List[Any]         =    FLAX_MODEL_MAPPING.get(self.config.vision_config.__class__						,	lowerCAmelCase__	).module_class

          _UpperCAmelCase					:  List[Any]         =    text_module(lowerCAmelCase__						,	dtype=self.dtype	)
          _UpperCAmelCase					:  Union[str, Any]         =    vision_module(lowerCAmelCase__						,	dtype=self.dtype	)

          _UpperCAmelCase					:  Optional[int]         =    nn.Dense(
              self.projection_dim						,	dtype=self.dtype						,	kernel_init=jax.nn.initializers.normal(0.0_2	)						,	use_bias=lowerCAmelCase__						,	)
          _UpperCAmelCase					:  List[str]         =    nn.Dense(
              self.projection_dim						,	dtype=self.dtype						,	kernel_init=jax.nn.initializers.normal(0.0_2	)						,	use_bias=lowerCAmelCase__						,	)
          _UpperCAmelCase					:  List[Any]         =    self.param("""logit_scale"""						,	jax.nn.initializers.ones						,	[]	)



     def __call__(self						,	lowerCAmelCase__=None						,	lowerCAmelCase__=None						,	lowerCAmelCase__=None						,	lowerCAmelCase__=None						,	lowerCAmelCase__=None						,	lowerCAmelCase__ = True						,	lowerCAmelCase__=None						,	lowerCAmelCase__=None						,	lowerCAmelCase__=None						,	):
          _UpperCAmelCase					:  int         =    return_dict if return_dict is not None else self.config.return_dict

          _UpperCAmelCase					:  Dict         =    self.vision_model(
              pixel_values=lowerCAmelCase__						,	deterministic=lowerCAmelCase__						,	output_attentions=lowerCAmelCase__						,	output_hidden_states=lowerCAmelCase__						,	return_dict=lowerCAmelCase__						,	)

          _UpperCAmelCase					:  int         =    self.text_model(
              input_ids=lowerCAmelCase__						,	attention_mask=lowerCAmelCase__						,	token_type_ids=lowerCAmelCase__						,	position_ids=lowerCAmelCase__						,	deterministic=lowerCAmelCase__						,	output_attentions=lowerCAmelCase__						,	output_hidden_states=lowerCAmelCase__						,	return_dict=lowerCAmelCase__						,	)

          _UpperCAmelCase					:  int         =    vision_outputs[1]
          _UpperCAmelCase					:  Dict         =    self.visual_projection(lowerCAmelCase__	)

          _UpperCAmelCase					:  List[str]         =    text_outputs[1]
          _UpperCAmelCase					:  List[Any]         =    self.text_projection(lowerCAmelCase__	)

          # normalized features
          _UpperCAmelCase					:  List[Any]         =    image_embeds / jnp.linalg.norm(lowerCAmelCase__						,	axis=-1						,	keepdims=lowerCAmelCase__	)
          _UpperCAmelCase					:  Optional[Any]         =    text_embeds / jnp.linalg.norm(lowerCAmelCase__						,	axis=-1						,	keepdims=lowerCAmelCase__	)

          # cosine similarity as logits
          _UpperCAmelCase					:  str         =    jnp.exp(self.logit_scale	)
          _UpperCAmelCase					:  str         =    jnp.matmul(lowerCAmelCase__						,	image_embeds.T	) * logit_scale
          _UpperCAmelCase					:  Any         =    logits_per_text.T

          if not return_dict:
               return (logits_per_image, logits_per_text, text_embeds, image_embeds, text_outputs, vision_outputs)

          return FlaxCLIPOutput(
              logits_per_image=lowerCAmelCase__						,	logits_per_text=lowerCAmelCase__						,	text_embeds=lowerCAmelCase__						,	image_embeds=lowerCAmelCase__						,	text_model_output=lowerCAmelCase__						,	vision_model_output=lowerCAmelCase__						,	)







class 	__lowerCAmelCase    (  __a				):
     snake_case   :    List[Any]							      =      HybridCLIPConfig
     snake_case   :    int							      =      FlaxHybridCLIPModule



     def __init__(self						,	lowerCAmelCase__						,	lowerCAmelCase__ = None						,	lowerCAmelCase__ = 0						,	lowerCAmelCase__ = jnp.floataa						,	**lowerCAmelCase__						,	):
          if input_shape is None:
               _UpperCAmelCase					:  Optional[Any]         =    ((1, 1), (1, config.vision_config.image_size, config.vision_config.image_size, 3))

          _UpperCAmelCase					:  Union[str, Any]         =    self.module_class(config=lowerCAmelCase__						,	dtype=lowerCAmelCase__						,	**lowerCAmelCase__	)
          super().__init__(lowerCAmelCase__						,	lowerCAmelCase__						,	input_shape=lowerCAmelCase__						,	seed=lowerCAmelCase__						,	dtype=lowerCAmelCase__	)



     def     snake_case_ (self						,	lowerCAmelCase__						,	lowerCAmelCase__						,	lowerCAmelCase__ = None	):
          # init input tensor
          _UpperCAmelCase					:  List[Any]         =    jnp.zeros(input_shape[0]						,	dtype="""i4"""	)
          _UpperCAmelCase					:  str         =    jnp.broadcast_to(jnp.arange(jnp.atleast_ad(lowerCAmelCase__	).shape[-1]	)						,	input_shape[0]	)
          _UpperCAmelCase					:  List[Any]         =    jnp.ones_like(lowerCAmelCase__	)
          _UpperCAmelCase					:  List[str]         =    jnp.ones_like(lowerCAmelCase__	)

          _UpperCAmelCase					:  Any         =    jax.random.normal(lowerCAmelCase__						,	input_shape[1]	)

          _UpperCAmelCase  ,     _UpperCAmelCase					:  int         =    jax.random.split(lowerCAmelCase__	)
          _UpperCAmelCase					:  Any         =    {"""params""": params_rng, """dropout""": dropout_rng}

          return self.module.init(lowerCAmelCase__						,	lowerCAmelCase__						,	lowerCAmelCase__						,	lowerCAmelCase__						,	lowerCAmelCase__						,	lowerCAmelCase__	)["params"]



     def __call__(self						,	lowerCAmelCase__						,	lowerCAmelCase__						,	lowerCAmelCase__=None						,	lowerCAmelCase__=None						,	lowerCAmelCase__=None						,	lowerCAmelCase__ = None						,	lowerCAmelCase__ = None						,	lowerCAmelCase__ = False						,	lowerCAmelCase__ = None						,	lowerCAmelCase__ = None						,	lowerCAmelCase__ = None						,	):
          _UpperCAmelCase					:  Any         =    output_attentions if output_attentions is not None else self.config.output_attentions
          _UpperCAmelCase					:  int         =    (
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          _UpperCAmelCase					:  int         =    return_dict if return_dict is not None else self.config.return_dict

          if position_ids is None:
               _UpperCAmelCase					:  List[Any]         =    jnp.broadcast_to(jnp.arange(jnp.atleast_ad(lowerCAmelCase__	).shape[-1]	)						,	input_ids.shape	)

          if token_type_ids is None:
               _UpperCAmelCase					:  List[str]         =    jnp.zeros_like(lowerCAmelCase__	)

          if attention_mask is None:
               _UpperCAmelCase					:  Any         =    jnp.ones_like(lowerCAmelCase__	)

          # Handle any PRNG if needed
          _UpperCAmelCase					:  List[str]         =    {}
          if dropout_rng is not None:
               _UpperCAmelCase					:  Union[str, Any]         =    dropout_rng

          return self.module.apply(
              {"""params""": params or self.params}						,	jnp.array(lowerCAmelCase__						,	dtype="""i4"""	)						,	jnp.array(lowerCAmelCase__						,	dtype=jnp.floataa	)						,	jnp.array(lowerCAmelCase__						,	dtype="""i4"""	)						,	jnp.array(lowerCAmelCase__						,	dtype="""i4"""	)						,	jnp.array(lowerCAmelCase__						,	dtype="""i4"""	)						,	not train						,	lowerCAmelCase__						,	lowerCAmelCase__						,	lowerCAmelCase__						,	rngs=lowerCAmelCase__						,	)



     def     snake_case_ (self						,	lowerCAmelCase__						,	lowerCAmelCase__=None						,	lowerCAmelCase__=None						,	lowerCAmelCase__=None						,	lowerCAmelCase__ = None						,	lowerCAmelCase__ = None						,	lowerCAmelCase__=False						,	):
          if position_ids is None:
               _UpperCAmelCase					:  str         =    jnp.broadcast_to(jnp.arange(jnp.atleast_ad(lowerCAmelCase__	).shape[-1]	)						,	input_ids.shape	)

          if token_type_ids is None:
               _UpperCAmelCase					:  str         =    jnp.zeros_like(lowerCAmelCase__	)

          if attention_mask is None:
               _UpperCAmelCase					:  Optional[Any]         =    jnp.ones_like(lowerCAmelCase__	)

          # Handle any PRNG if needed
          _UpperCAmelCase					:  str         =    {}
          if dropout_rng is not None:
               _UpperCAmelCase					:  List[Any]         =    dropout_rng

          def _get_features(lowerCAmelCase__						,	lowerCAmelCase__						,	lowerCAmelCase__						,	lowerCAmelCase__						,	lowerCAmelCase__						,	lowerCAmelCase__	):
               _UpperCAmelCase					:  Union[str, Any]         =    module.text_model(
                   input_ids=lowerCAmelCase__						,	attention_mask=lowerCAmelCase__						,	position_ids=lowerCAmelCase__						,	token_type_ids=lowerCAmelCase__						,	deterministic=lowerCAmelCase__						,	)
               _UpperCAmelCase					:  Optional[int]         =    text_outputs[1]
               _UpperCAmelCase					:  List[Any]         =    module.text_projection(lowerCAmelCase__	)
               return text_features

          return self.module.apply(
              {"""params""": params or self.params}						,	jnp.array(lowerCAmelCase__						,	dtype="""i4"""	)						,	jnp.array(lowerCAmelCase__						,	dtype="""i4"""	)						,	jnp.array(lowerCAmelCase__						,	dtype="""i4"""	)						,	jnp.array(lowerCAmelCase__						,	dtype="""i4"""	)						,	not train						,	method=_get_features						,	rngs=lowerCAmelCase__						,	)



     def     snake_case_ (self						,	lowerCAmelCase__						,	lowerCAmelCase__ = None						,	lowerCAmelCase__ = None						,	lowerCAmelCase__=False	):
          _UpperCAmelCase					:  Any         =    {}
          if dropout_rng is not None:
               _UpperCAmelCase					:  int         =    dropout_rng

          def _get_features(lowerCAmelCase__						,	lowerCAmelCase__						,	lowerCAmelCase__	):
               _UpperCAmelCase					:  Optional[Any]         =    module.vision_model(pixel_values=lowerCAmelCase__						,	deterministic=lowerCAmelCase__	)
               _UpperCAmelCase					:  int         =    vision_outputs[1]  # pooled_output
               _UpperCAmelCase					:  Optional[int]         =    module.visual_projection(lowerCAmelCase__	)
               return image_features

          return self.module.apply(
              {"""params""": params or self.params}						,	jnp.array(lowerCAmelCase__						,	dtype=jnp.floataa	)						,	not train						,	method=_get_features						,	rngs=lowerCAmelCase__						,	)



     @classmethod
     def     snake_case_ (cls						,	lowerCAmelCase__ = None						,	lowerCAmelCase__ = None						,	*lowerCAmelCase__						,	**lowerCAmelCase__						,	):
          _UpperCAmelCase					:  List[Any]         =    {
              argument[len("""text_"""	) :]: value for argument, value in kwargs.items() if argument.startswith("""text_"""	)
          }

          _UpperCAmelCase					:  Tuple         =    {
              argument[len("""vision_"""	) :]: value for argument, value in kwargs.items() if argument.startswith("""vision_"""	)
          }

          # remove text, vision kwargs from kwargs
          for key in kwargs_text.keys():
               del kwargs["text_" + key]
          for key in kwargs_vision.keys():
               del kwargs["vision_" + key]

          # Load and initialize the text and vision model
          _UpperCAmelCase					:  List[Any]         =    kwargs_text.pop("""model"""						,	lowerCAmelCase__	)
          if text_model is None:
               assert (
                   text_model_name_or_path is not None
               ), "If `model` is not defined as an argument, a `text_model_name_or_path` has to be defined"
               from transformers import FlaxAutoModel

               if "config" not in kwargs_text:
                    from transformers import AutoConfig

                    _UpperCAmelCase					:  Any         =    AutoConfig.from_pretrained(lowerCAmelCase__	)
                    _UpperCAmelCase					:  int         =    text_config

               _UpperCAmelCase					:  Any         =    FlaxAutoModel.from_pretrained(lowerCAmelCase__						,	*lowerCAmelCase__						,	**lowerCAmelCase__	)

          _UpperCAmelCase					:  List[Any]         =    kwargs_vision.pop("""model"""						,	lowerCAmelCase__	)
          if vision_model is None:
               assert (
                   vision_model_name_or_path is not None
               ), "If `model` is not defined as an argument, a `vision_model_name_or_path` has to be defined"
               from transformers import FlaxAutoModel

               if "config" not in kwargs_vision:
                    from transformers import AutoConfig

                    _UpperCAmelCase					:  Union[str, Any]         =    AutoConfig.from_pretrained(lowerCAmelCase__	)
                    _UpperCAmelCase					:  Any         =    vision_config

               _UpperCAmelCase					:  Tuple         =    FlaxAutoModel.from_pretrained(lowerCAmelCase__						,	*lowerCAmelCase__						,	**lowerCAmelCase__	)

          # instantiate config with corresponding kwargs
          _UpperCAmelCase					:  List[Any]         =    kwargs.pop("""dtype"""						,	jnp.floataa	)
          _UpperCAmelCase					:  List[Any]         =    HybridCLIPConfig.from_text_vision_configs(text_model.config						,	vision_model.config						,	**lowerCAmelCase__	)

          # init model
          _UpperCAmelCase					:  Optional[Any]         =    cls(lowerCAmelCase__						,	*lowerCAmelCase__						,	dtype=lowerCAmelCase__						,	**lowerCAmelCase__	)

          if vision_config.model_type == "clip":
               _UpperCAmelCase					:  str         =    vision_model.params["""vision_model"""]
               _UpperCAmelCase					:  int         =    vision_model.params["""visual_projection"""]["""kernel"""]
          else:
               _UpperCAmelCase					:  List[str]         =    vision_model.params

          _UpperCAmelCase					:  Any         =    text_model.params

          return model


