






"""simple docstring"""



import argparse
import collections

import jax
import jax.numpy as jnp
import torch
import torch.nn as nn
from clip.model import CLIP
from flax.training import checkpoints
from huggingface_hub import Repository

from transformers import (
    CLIPTokenizer,
    OwlViTConfig,
    OwlViTForObjectDetection,
    OwlViTImageProcessor,
    OwlViTModel,
    OwlViTProcessor,
)


_lowerCAmelCase     :     Tuple            =	{
    """vit_b32""": {
        """embed_dim""": 512,
        """image_resolution""": 768,
        """context_length""": 16,
        """vocab_size""": 49_408,
        """vision_layers""": 12,
        """vision_width""": 768,
        """vision_patch_size""": 32,
        """transformer_width""": 512,
        """transformer_heads""": 8,
        """transformer_layers""": 12,
    },
    """vit_b16""": {
        """embed_dim""": 512,
        """image_resolution""": 768,
        """context_length""": 16,
        """vocab_size""": 49_408,
        """vision_layers""": 12,
        """vision_width""": 768,
        """vision_patch_size""": 16,
        """transformer_width""": 512,
        """transformer_heads""": 8,
        """transformer_layers""": 12,
    },
    """vit_l14""": {
        """embed_dim""": 768,
        """image_resolution""": 840,
        """context_length""": 16,
        """vocab_size""": 49_408,
        """vision_layers""": 24,
        """vision_width""": 1_024,
        """vision_patch_size""": 14,
        """transformer_width""": 768,
        """transformer_heads""": 12,
        """transformer_layers""": 12,
    },
}


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      Tuple       , snake_case    :      Tuple=""       , snake_case    :      int="/"							)->						Optional[Any]:






     '''simple docstring'''



     UpperCAmelCase__		:  Tuple				=				[]

     for k, v in params.items():
          UpperCAmelCase__		:  Union[str, Any]				=				parent_key + sep + k if parent_key else k

          if isinstance(snake_case       , collections.MutableMapping							):
               items.extend(flatten_nested_dict(snake_case       , snake_case       , sep=snake_case							).items()							)
          else:
               items.append((new_key, v)							)
     return dict(snake_case							)


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      List[str]							)->						str:






     '''simple docstring'''



     return jax.tree_util.tree_map(lambda snake_case							: x.astype(jnp.floataa							) if x.dtype == jnp.bfloataa else x       , snake_case							)


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      Optional[Any]       , snake_case    :      Optional[int]							)->						Optional[Any]:






     '''simple docstring'''



     UpperCAmelCase__				,							UpperCAmelCase__				,							UpperCAmelCase__		:  int				=				pt_attn_layer.in_proj_weight.chunk(3       , dim=0							)
     UpperCAmelCase__				,							UpperCAmelCase__				,							UpperCAmelCase__		:  Any				=				pt_attn_layer.in_proj_bias.chunk(3       , dim=0							)

     UpperCAmelCase__		:  Optional[Any]				=				pt_attn_layer.out_proj.weight
     UpperCAmelCase__		:  Any				=				pt_attn_layer.out_proj.bias

     UpperCAmelCase__		:  Dict				=				q_proj
     UpperCAmelCase__		:  Optional[Any]				=				q_proj_bias

     UpperCAmelCase__		:  Optional[Any]				=				k_proj
     UpperCAmelCase__		:  int				=				k_proj_bias

     UpperCAmelCase__		:  List[str]				=				v_proj
     UpperCAmelCase__		:  Tuple				=				v_proj_bias

     UpperCAmelCase__		:  List[Any]				=				out_proj_weights
     UpperCAmelCase__		:  Union[str, Any]				=				out_proj_bias


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      Optional[int]       , snake_case    :      Optional[int]							)->						str:






     '''simple docstring'''



     copy_linear(hf_mlp.fca       , pt_mlp.c_fc							)
     copy_linear(hf_mlp.fca       , pt_mlp.c_proj							)


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      Optional[Any]       , snake_case    :      Any							)->						Dict:






     '''simple docstring'''



     UpperCAmelCase__		:  Optional[int]				=				pt_linear.weight
     UpperCAmelCase__		:  Optional[int]				=				pt_linear.bias


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      Dict       , snake_case    :      List[Any]							)->						Dict:






     '''simple docstring'''



     copy_linear(hf_layer.layer_norma       , pt_layer.ln_a							)
     copy_linear(hf_layer.layer_norma       , pt_layer.ln_a							)

     # copy MLP
     copy_mlp(hf_layer.mlp       , pt_layer.mlp							)

     # copy attn
     copy_attn_layer(hf_layer.self_attn       , pt_layer.attn							)


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      List[str]       , snake_case    :      Optional[int]							)->						Union[str, Any]:






     '''simple docstring'''



     for hf_layer, pt_layer in zip(snake_case       , snake_case							):
          copy_layer(snake_case       , snake_case							)


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      str       , snake_case    :      Tuple							)->						int:






     '''simple docstring'''



     UpperCAmelCase__		:  int				=				pt_model.token_embedding.weight
     UpperCAmelCase__		:  Any				=				pt_model.positional_embedding

     # copy layer norm
     copy_linear(hf_encoder.final_layer_norm       , pt_model.ln_final							)

     # copy hidden layers
     copy_layers(hf_encoder.encoder.layers       , pt_model.transformer.resblocks							)


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      Dict       , snake_case    :      int							)->						Union[str, Any]:






     '''simple docstring'''



     UpperCAmelCase__		:  int				=				pt_model.text_projection.data.T

     # copy text encoder
     copy_encoder(hf_model.text_model       , snake_case							)


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      Dict       , snake_case    :      List[Any]							)->						Any:






     '''simple docstring'''



     UpperCAmelCase__		:  Dict				=				pt_model.visual.proj.data.T

     # copy layer norms
     copy_linear(hf_model.vision_model.pre_layernorm       , pt_model.visual.ln_pre							)
     copy_linear(hf_model.vision_model.post_layernorm       , pt_model.visual.ln_post							)

     # copy embeds
     UpperCAmelCase__		:  Tuple				=				pt_model.visual.conva.weight.data
     UpperCAmelCase__		:  Optional[int]				=				pt_model.visual.class_embedding
     UpperCAmelCase__		:  Optional[int]				=				pt_model.visual.positional_embedding.data

     # copy encoder
     copy_layers(hf_model.vision_model.encoder.layers       , pt_model.visual.transformer.resblocks							)


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      Any       , snake_case    :      Optional[Any]							)->						List[str]:






     '''simple docstring'''



     UpperCAmelCase__		:  List[str]				=				flatten_nested_dict(flax_params["backbone"]["merged_class_token"]							)

     UpperCAmelCase__		:  str				=				torch.from_numpy(flax_class_token_params["scale"]							)
     UpperCAmelCase__		:  Tuple				=				torch.from_numpy(flax_class_token_params["bias"]							)
     UpperCAmelCase__		:  Tuple				=				nn.Parameter(snake_case							)
     UpperCAmelCase__		:  Optional[int]				=				nn.Parameter(snake_case							)


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      int       , snake_case    :      int							)->						Optional[Any]:






     '''simple docstring'''



     UpperCAmelCase__		:  int				=				hf_model.state_dict()
     UpperCAmelCase__		:  Dict				=				{}

     # Rename class prediction head flax params to pytorch HF
     UpperCAmelCase__		:  Optional[int]				=				flatten_nested_dict(flax_params["class_head"]							)

     for flax_key, v in flax_class_params.items():
          UpperCAmelCase__		:  int				=				flax_key.replace("/"       , "."							)
          UpperCAmelCase__		:  Tuple				=				torch_key.replace(".kernel"       , ".weight"							)
          UpperCAmelCase__		:  str				=				torch_key.replace("Dense_0"       , "dense0"							)
          UpperCAmelCase__		:  str				=				"class_head." + torch_key

          if "weight" in torch_key and v.ndim == 2:
               UpperCAmelCase__		:  Any				=				v.T

          UpperCAmelCase__		:  Optional[int]				=				nn.Parameter(torch.from_numpy(snake_case							)							)

     # Rename box prediction box flax params to pytorch HF
     UpperCAmelCase__		:  str				=				flatten_nested_dict(flax_params["obj_box_head"]							)

     for flax_key, v in flax_box_params.items():
          UpperCAmelCase__		:  Optional[int]				=				flax_key.replace("/"       , "."							)
          UpperCAmelCase__		:  List[Any]				=				torch_key.replace(".kernel"       , ".weight"							)
          UpperCAmelCase__		:  Union[str, Any]				=				torch_key.replace("_"       , ""							).lower()
          UpperCAmelCase__		:  Optional[int]				=				"box_head." + torch_key

          if "weight" in torch_key and v.ndim == 2:
               UpperCAmelCase__		:  Tuple				=				v.T

          UpperCAmelCase__		:  Optional[int]				=				nn.Parameter(torch.from_numpy(snake_case							)							)

     # Copy flax params to PyTorch params
     for name, param in new_params.items():
          if name in pt_params.keys():
               pt_params[name].copy_(snake_case							)


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      Dict       , snake_case    :      str							)->						Tuple:






     '''simple docstring'''



     for k, v in flax_attn_params.items():
          if k.startswith("transformer"							):
               UpperCAmelCase__		:  List[str]				=				k.replace("transformer.resblocks"       , "text_model.encoder.layers"							)
          else:
               UpperCAmelCase__		:  Dict				=				k.replace("visual.transformer.resblocks"       , "vision_model.encoder.layers"							)

          UpperCAmelCase__		:  str				=				torch_key.replace("attn"       , "self_attn"							)
          UpperCAmelCase__		:  Tuple				=				torch_key.replace("key"       , "k_proj"							)
          UpperCAmelCase__		:  Union[str, Any]				=				torch_key.replace("value"       , "v_proj"							)
          UpperCAmelCase__		:  Tuple				=				torch_key.replace("query"       , "q_proj"							)
          UpperCAmelCase__		:  Tuple				=				torch_key.replace("out"       , "out_proj"							)

          if "bias" in torch_key and v.ndim == 2:
               UpperCAmelCase__		:  Dict				=				v.shape[0] * v.shape[1]
               UpperCAmelCase__		:  Tuple				=				v.reshape(snake_case							)

          if "weight" in torch_key and "out" in torch_key:
               UpperCAmelCase__		:  int				=				(v.shape[0] * v.shape[1], v.shape[2])
               UpperCAmelCase__		:  Any				=				v.reshape(snake_case							).T

          if "weight" in torch_key and "out" not in torch_key:
               UpperCAmelCase__		:  Union[str, Any]				=				(v.shape[0], v.shape[1] * v.shape[2])
               UpperCAmelCase__		:  Dict				=				v.reshape(snake_case							).T

          # Copy flax CLIP attn params to HF PyTorch params
          UpperCAmelCase__		:  Union[str, Any]				=				torch.from_numpy(snake_case							)
          hf_backbone.state_dict()[torch_key].copy_(snake_case							)


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      List[str]							)->						int:






     '''simple docstring'''



     UpperCAmelCase__		:  str				=				{}
     UpperCAmelCase__		:  List[Any]				=				[]

     for k, v in params.items():
          if "attn." in k:
               UpperCAmelCase__		:  Dict				=				k[: k.rindex("attn."							) + 5]
               if base in processed_attn_layers:
                    continue

               processed_attn_layers.append(snake_case							)
               UpperCAmelCase__		:  Tuple				=				params[base + "out.weight"].shape[-1]
               UpperCAmelCase__		:  str				=				params[base + "out.weight"].reshape(snake_case       , snake_case							).T
               UpperCAmelCase__		:  str				=				params[base + "out.bias"]
          else:
               UpperCAmelCase__		:  List[str]				=				v
     return new_params


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      int       , snake_case    :      str							)->						Union[str, Any]:






     '''simple docstring'''



     UpperCAmelCase__		:  Optional[int]				=				CLIP(**snake_case							)
     torch_model.eval()
     UpperCAmelCase__		:  Dict				=				torch_model.state_dict()

     UpperCAmelCase__		:  Any				=				flatten_nested_dict(flax_params["backbone"]["clip"]							)
     UpperCAmelCase__		:  Tuple				=				{}

     for flax_key, v in flax_clip_params.items():
          UpperCAmelCase__		:  Union[str, Any]				=				flax_key.replace("/"       , "."							)
          UpperCAmelCase__		:  str				=				torch_key.replace("text.token_embedding.embedding"       , "token_embedding.kernel"							)

          if (
              torch_key.startswith("text.transformer"							)
              or torch_key.startswith("text.text_projection"							)
              or torch_key.startswith("text.ln_final"							)
              or torch_key.startswith("text.positional_embedding"							)
          ):
               UpperCAmelCase__		:  List[str]				=				torch_key[5:]

          UpperCAmelCase__		:  Optional[Any]				=				torch_key.replace("text_projection.kernel"       , "text_projection"							)
          UpperCAmelCase__		:  Union[str, Any]				=				torch_key.replace("visual.proj.kernel"       , "visual.proj"							)
          UpperCAmelCase__		:  Any				=				torch_key.replace(".scale"       , ".weight"							)
          UpperCAmelCase__		:  Dict				=				torch_key.replace(".kernel"       , ".weight"							)

          if "conv" in torch_key or "downsample.0.weight" in torch_key:
               UpperCAmelCase__		:  Union[str, Any]				=				v.transpose(3       , 2       , 0       , 1							)

          elif "weight" in torch_key and v.ndim == 2 and "embedding" not in torch_key:
               # Fully connected layers are transposed, embeddings are not
               UpperCAmelCase__		:  Dict				=				v.T

          UpperCAmelCase__		:  int				=				v

     UpperCAmelCase__		:  Tuple				=				_convert_attn_layers(snake_case							)
     new_torch_params.update(snake_case							)
     UpperCAmelCase__		:  List[Any]				=				{}

     # Copy flax CLIP backbone params to PyTorch params
     for name, param in new_torch_params.items():
          if name in torch_clip_params.keys():
               UpperCAmelCase__		:  List[str]				=				torch.from_numpy(new_torch_params[name]							)
               torch_clip_params[name].copy_(snake_case							)
          else:
               UpperCAmelCase__		:  Any				=				param

     return torch_clip_params, torch_model, attn_params


@torch.no_grad()
def      SCREAMING_SNAKE_CASE__    (   snake_case    :      int       , snake_case    :      Dict       , snake_case    :      Union[str, Any]       , snake_case    :      Optional[int]       , snake_case    :      Union[str, Any]=None							)->						str:






     '''simple docstring'''



     UpperCAmelCase__		:  Any				=				Repository(snake_case       , clone_from=f'google/{pytorch_dump_folder_path}'							)
     repo.git_pull()

     if config_path is not None:
          UpperCAmelCase__		:  Union[str, Any]				=				OwlViTConfig.from_pretrained(snake_case							)
     else:
          UpperCAmelCase__		:  int				=				OwlViTConfig()

     UpperCAmelCase__		:  str				=				OwlViTModel(snake_case							).eval()
     UpperCAmelCase__		:  Any				=				OwlViTForObjectDetection(snake_case							).eval()

     copy_text_model_and_projection(snake_case       , snake_case							)
     copy_vision_model_and_projection(snake_case       , snake_case							)
     UpperCAmelCase__		:  Optional[int]				=				pt_backbone.logit_scale
     copy_flax_attn_params(snake_case       , snake_case							)

     UpperCAmelCase__		:  str				=				hf_backbone
     copy_class_merge_token(snake_case       , snake_case							)
     copy_class_box_heads(snake_case       , snake_case							)

     # Save HF model
     hf_model.save_pretrained(repo.local_dir							)

     # Initialize image processor
     UpperCAmelCase__		:  int				=				OwlViTImageProcessor(
         size=config.vision_config.image_size       , crop_size=config.vision_config.image_size							)
     # Initialize tokenizer
     UpperCAmelCase__		:  str				=				CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32"       , pad_token="!"       , model_max_length=16							)

     # Initialize processor
     UpperCAmelCase__		:  Optional[int]				=				OwlViTProcessor(image_processor=snake_case       , tokenizer=snake_case							)
     image_processor.save_pretrained(repo.local_dir							)
     processor.save_pretrained(repo.local_dir							)

     repo.git_add()
     repo.git_commit("Upload model and processor"							)
     repo.git_push()


if __name__ == "__main__":
 _lowerCAmelCase     :     List[str]            =	argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     """--owlvit_version""",
     default=None,
     type=str,
     required=True,
     help="""OWL-ViT model name [clip_b16, clip_b32, clip_l14].""",
 )
 parser.add_argument(
     """--owlvit_checkpoint""", default=None, type=str, required=True, help="""Path to flax model checkpoint."""
 )
 parser.add_argument("""--hf_config""", default=None, type=str, required=True, help="""Path to HF model config.""")
 parser.add_argument(
     """--pytorch_dump_folder_path""", default="""hf_model""", type=str, help="""Path to the output PyTorch model."""
 )
 _lowerCAmelCase     :     Optional[Any]            =	parser.parse_args()

 # Initialize PyToch clip model
 _lowerCAmelCase     :     str            =	args.owlvit_version
 if model_name == "clip_b16":
  _lowerCAmelCase     :     List[Any]            =	CONFIGS["""vit_b16"""]
 elif model_name == "clip_b32":
  _lowerCAmelCase     :     int            =	CONFIGS["""vit_b32"""]
 elif model_name == "clip_l14":
  _lowerCAmelCase     :     Dict            =	CONFIGS["""vit_l14"""]

 # Load from checkpoint and convert params to float-32
 _lowerCAmelCase     :     Tuple            =	checkpoints.restore_checkpoint(args.owlvit_checkpoint, target=None)["""optimizer"""]["""target"""]
 _lowerCAmelCase     :     List[str]            =	jax.tree_util.tree_map(lambda x: x.astype(jnp.floataa) if x.dtype == jnp.bfloataa else x, variables)
 del variables

 # Convert CLIP backbone
 _lowerCAmelCase       ,   _lowerCAmelCase       ,   _lowerCAmelCase     :     Any            =	convert_clip_backbone(flax_params, torch_config)

 convert_owlvit_checkpoint(clip_pt, flax_params, attn_params, args.pytorch_dump_folder_path, args.hf_config)










"""simple docstring"""



import requests
from bsa import BeautifulSoup


def      SCREAMING_SNAKE_CASE__    (   snake_case    :      int       , snake_case    :      str							)->						str:






     '''simple docstring'''



     UpperCAmelCase__		:  Union[str, Any]				=				(
         "https://www.horoscope.com/us/horoscopes/general/"
         f'horoscope-general-daily-{day}.aspx?sign={zodiac_sign}'
     )
     UpperCAmelCase__		:  List[str]				=				BeautifulSoup(requests.get(snake_case							).content       , "html.parser"							)
     return soup.find("div"       , class_="main-horoscope"							).p.text


if __name__ == "__main__":
 print("""Daily Horoscope. \n""")
 print(
     """enter your Zodiac sign number:\n""",
     """1. Aries\n""",
     """2. Taurus\n""",
     """3. Gemini\n""",
     """4. Cancer\n""",
     """5. Leo\n""",
     """6. Virgo\n""",
     """7. Libra\n""",
     """8. Scorpio\n""",
     """9. Sagittarius\n""",
     """10. Capricorn\n""",
     """11. Aquarius\n""",
     """12. Pisces\n""",
 )
 _lowerCAmelCase     :     List[str]            =	int(input("""number> """).strip())
 print("""choose some day:\n""", """yesterday\n""", """today\n""", """tomorrow\n""")
 _lowerCAmelCase     :     int            =	input("""enter the day> """)
 _lowerCAmelCase     :     Any            =	horoscope(zodiac_sign, day)
 print(horoscope_text)


