


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


lowercase__					  =		logging.get_logger(__name__)





class     __SCREAMING_SNAKE_CASE       (   nn.Module			):
     UpperCAmelCase			       =					42
     UpperCAmelCase			       =					jnp.floataa






     def 			a_       (      self		)							->     List[str]:
          _a            =		self.config.text_config
          _a            =		self.config.vision_config

          _a            =		self.config.projection_dim
          _a            =		text_config.hidden_size
          _a            =		vision_config.hidden_size

          _a            =		FLAX_MODEL_MAPPING[self.config.text_config.__class__].module_class
          _a            =		FLAX_MODEL_MAPPING.get(self.config.vision_config.__class__  ,				__UpperCamelCase		).module_class

          _a            =		text_module(__UpperCamelCase  ,				dtype=self.dtype		)
          _a            =		vision_module(__UpperCamelCase  ,				dtype=self.dtype		)

          _a            =		nn.Dense(
              self.projection_dim  ,				dtype=self.dtype  ,				kernel_init=jax.nn.initializers.normal(0.02		)  ,				use_bias=__UpperCamelCase  ,				)
          _a            =		nn.Dense(
              self.projection_dim  ,				dtype=self.dtype  ,				kernel_init=jax.nn.initializers.normal(0.02		)  ,				use_bias=__UpperCamelCase  ,				)
          _a            =		self.param("logit_scale"  ,				jax.nn.initializers.ones  ,				[]		)






     def __call__(      self  ,				__UpperCamelCase=None  ,				__UpperCamelCase=None  ,				__UpperCamelCase=None  ,				__UpperCamelCase=None  ,				__UpperCamelCase=None  ,				__UpperCamelCase = True  ,				__UpperCamelCase=None  ,				__UpperCamelCase=None  ,				__UpperCamelCase=None  ,				)							->     Dict:
          _a            =		return_dict if return_dict is not None else self.config.return_dict

          _a            =		self.vision_model(
              pixel_values=__UpperCamelCase  ,				deterministic=__UpperCamelCase  ,				output_attentions=__UpperCamelCase  ,				output_hidden_states=__UpperCamelCase  ,				return_dict=__UpperCamelCase  ,				)

          _a            =		self.text_model(
              input_ids=__UpperCamelCase  ,				attention_mask=__UpperCamelCase  ,				token_type_ids=__UpperCamelCase  ,				position_ids=__UpperCamelCase  ,				deterministic=__UpperCamelCase  ,				output_attentions=__UpperCamelCase  ,				output_hidden_states=__UpperCamelCase  ,				return_dict=__UpperCamelCase  ,				)

          _a            =		vision_outputs[1]
          _a            =		self.visual_projection(__UpperCamelCase		)

          _a            =		text_outputs[1]
          _a            =		self.text_projection(__UpperCamelCase		)

          # normalized features
          _a            =		image_embeds / jnp.linalg.norm(__UpperCamelCase  ,				axis=-1  ,				keepdims=__UpperCamelCase		)
          _a            =		text_embeds / jnp.linalg.norm(__UpperCamelCase  ,				axis=-1  ,				keepdims=__UpperCamelCase		)

          # cosine similarity as logits
          _a            =		jnp.exp(self.logit_scale		)
          _a            =		jnp.matmul(__UpperCamelCase  ,				image_embeds.T		) * logit_scale
          _a            =		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=__UpperCamelCase  ,				logits_per_text=__UpperCamelCase  ,				text_embeds=__UpperCamelCase  ,				image_embeds=__UpperCamelCase  ,				text_model_output=__UpperCamelCase  ,				vision_model_output=__UpperCamelCase  ,				)







class     __SCREAMING_SNAKE_CASE       (   lowerCamelCase__			):
     UpperCAmelCase			       =					HybridCLIPConfig
     UpperCAmelCase			       =					FlaxHybridCLIPModule






     def __init__(      self  ,				__UpperCamelCase  ,				__UpperCamelCase = None  ,				__UpperCamelCase = 0  ,				__UpperCamelCase = jnp.floataa  ,				**__UpperCamelCase  ,				)							->     List[str]:
          if input_shape is None:
               _a            =		((1, 1), (1, config.vision_config.image_size, config.vision_config.image_size, 3))

          _a            =		self.module_class(config=__UpperCamelCase  ,				dtype=__UpperCamelCase  ,				**__UpperCamelCase		)
          super().__init__(__UpperCamelCase  ,				__UpperCamelCase  ,				input_shape=__UpperCamelCase  ,				seed=__UpperCamelCase  ,				dtype=__UpperCamelCase		)






     def 			a_       (      self  ,				__UpperCamelCase  ,				__UpperCamelCase  ,				__UpperCamelCase = None		)							->     FrozenDict:
          # init input tensor
          _a            =		jnp.zeros(input_shape[0]  ,				dtype="i4"		)
          _a            =		jnp.broadcast_to(jnp.arange(jnp.atleast_ad(__UpperCamelCase		).shape[-1]		)  ,				input_shape[0]		)
          _a            =		jnp.ones_like(__UpperCamelCase		)
          _a            =		jnp.ones_like(__UpperCamelCase		)

          _a            =		jax.random.normal(__UpperCamelCase  ,				input_shape[1]		)

          _a      ,      _a            =		jax.random.split(__UpperCamelCase		)
          _a            =		{"params": params_rng, "dropout": dropout_rng}

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






     def __call__(      self  ,				__UpperCamelCase  ,				__UpperCamelCase  ,				__UpperCamelCase=None  ,				__UpperCamelCase=None  ,				__UpperCamelCase=None  ,				__UpperCamelCase = None  ,				__UpperCamelCase = None  ,				__UpperCamelCase = False  ,				__UpperCamelCase = None  ,				__UpperCamelCase = None  ,				__UpperCamelCase = None  ,				)							->     Any:
          _a            =		output_attentions if output_attentions is not None else self.config.output_attentions
          _a            =		(
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          _a            =		return_dict if return_dict is not None else self.config.return_dict

          if position_ids is None:
               _a            =		jnp.broadcast_to(jnp.arange(jnp.atleast_ad(__UpperCamelCase		).shape[-1]		)  ,				input_ids.shape		)

          if token_type_ids is None:
               _a            =		jnp.zeros_like(__UpperCamelCase		)

          if attention_mask is None:
               _a            =		jnp.ones_like(__UpperCamelCase		)

          # Handle any PRNG if needed
          _a            =		{}
          if dropout_rng is not None:
               _a            =		dropout_rng

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






     def 			a_       (      self  ,				__UpperCamelCase  ,				__UpperCamelCase=None  ,				__UpperCamelCase=None  ,				__UpperCamelCase=None  ,				__UpperCamelCase = None  ,				__UpperCamelCase = None  ,				__UpperCamelCase=False  ,				)							->     Tuple:
          if position_ids is None:
               _a            =		jnp.broadcast_to(jnp.arange(jnp.atleast_ad(__UpperCamelCase		).shape[-1]		)  ,				input_ids.shape		)

          if token_type_ids is None:
               _a            =		jnp.zeros_like(__UpperCamelCase		)

          if attention_mask is None:
               _a            =		jnp.ones_like(__UpperCamelCase		)

          # Handle any PRNG if needed
          _a            =		{}
          if dropout_rng is not None:
               _a            =		dropout_rng

          def _get_features(__UpperCamelCase  ,				__UpperCamelCase  ,				__UpperCamelCase  ,				__UpperCamelCase  ,				__UpperCamelCase  ,				__UpperCamelCase		):
               _a            =		module.text_model(
                   input_ids=__UpperCamelCase  ,				attention_mask=__UpperCamelCase  ,				position_ids=__UpperCamelCase  ,				token_type_ids=__UpperCamelCase  ,				deterministic=__UpperCamelCase  ,				)
               _a            =		text_outputs[1]
               _a            =		module.text_projection(__UpperCamelCase		)
               return text_features

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






     def 			a_       (      self  ,				__UpperCamelCase  ,				__UpperCamelCase = None  ,				__UpperCamelCase = None  ,				__UpperCamelCase=False		)							->     Optional[Any]:
          _a            =		{}
          if dropout_rng is not None:
               _a            =		dropout_rng

          def _get_features(__UpperCamelCase  ,				__UpperCamelCase  ,				__UpperCamelCase		):
               _a            =		module.vision_model(pixel_values=__UpperCamelCase  ,				deterministic=__UpperCamelCase		)
               _a            =		vision_outputs[1]  # pooled_output
               _a            =		module.visual_projection(__UpperCamelCase		)
               return image_features

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






     @classmethod
     def 			a_       (      cls  ,				__UpperCamelCase = None  ,				__UpperCamelCase = None  ,				*__UpperCamelCase  ,				**__UpperCamelCase  ,				)							->     FlaxPreTrainedModel:
          _a            =		{
              argument[len("text_"		) :]: value for argument, value in kwargs.items() if argument.startswith("text_"		)
          }

          _a            =		{
              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
          _a            =		kwargs_text.pop("model"  ,				__UpperCamelCase		)
          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

                    _a            =		AutoConfig.from_pretrained(__UpperCamelCase		)
                    _a            =		text_config

               _a            =		FlaxAutoModel.from_pretrained(__UpperCamelCase  ,				*__UpperCamelCase  ,				**__UpperCamelCase		)

          _a            =		kwargs_vision.pop("model"  ,				__UpperCamelCase		)
          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

                    _a            =		AutoConfig.from_pretrained(__UpperCamelCase		)
                    _a            =		vision_config

               _a            =		FlaxAutoModel.from_pretrained(__UpperCamelCase  ,				*__UpperCamelCase  ,				**__UpperCamelCase		)

          # instantiate config with corresponding kwargs
          _a            =		kwargs.pop("dtype"  ,				jnp.floataa		)
          _a            =		HybridCLIPConfig.from_text_vision_configs(text_model.config  ,				vision_model.config  ,				**__UpperCamelCase		)

          # init model
          _a            =		cls(__UpperCamelCase  ,				*__UpperCamelCase  ,				dtype=__UpperCamelCase  ,				**__UpperCamelCase		)

          if vision_config.model_type == "clip":
               _a            =		vision_model.params["vision_model"]
               _a            =		vision_model.params["visual_projection"]["kernel"]
          else:
               _a            =		vision_model.params

          _a            =		text_model.params

          return model





'''simple docstring'''

from __future__ import annotations






def __UpperCamelCase (      __lowerCamelCase		:			float | int   ,	__lowerCamelCase		:			float | int   ,	__lowerCamelCase		:			float | int   ,	)   ->  list[float | int]:







     '''simple docstring'''






     if not all((nth_term, start_term_a, common_ratio_r)					):
          return []
     _a            =		[]
     _a            =		1
     _a            =		common_ratio_r
     for _ in range(int(__lowerCamelCase					)					):
          if not series:
               series.append(__lowerCamelCase					)
          else:
               power += 1
               series.append(float(start_term_a * multiple					)					)
               _a            =		pow(float(__lowerCamelCase					)   ,	__lowerCamelCase					)
     return series


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   lowercase__					  =		float(input("Enter the last number (n term) of the Geometric Series"))
   lowercase__					  =		float(input("Enter the starting term (a) of the Geometric Series"))
   lowercase__					  =		float(
       input("Enter the common ratio between two terms (r) of the Geometric Series")
   )
   print("Formula of Geometric Series => a + ar + ar^2 ... +ar^n")
   print(geometric_series(nth_term, start_term_a, common_ratio_r))

