

'''simple docstring'''







import argparse

import requests
import torch
from PIL import Image

from transformers import CLIPProcessor, GroupViTConfig, GroupViTModel
def       UpperCAmelCase__    (      UpperCAmelCase__				)			->			str:
       # vision encoder
       if "img_encoder.pos_embed" in name:
              A_						=      name.replace("""img_encoder.pos_embed""",       """vision_model.embeddings.position_embeddings"""				)
       if "img_encoder.patch_embed.proj" in name:
              A_						=      name.replace("""img_encoder.patch_embed.proj""",       """vision_model.embeddings.patch_embeddings.projection"""				)
       if "img_encoder.patch_embed.norm" in name:
              A_						=      name.replace("""img_encoder.patch_embed.norm""",       """vision_model.embeddings.layernorm"""				)
       if "img_encoder.layers" in name:
              A_						=      name.replace("""img_encoder.layers""",       """vision_model.encoder.stages"""				)
       if "blocks" in name and "res" not in name:
              A_						=      name.replace("""blocks""",       """layers"""				)
       if "attn" in name and "pre_assign" not in name:
              A_						=      name.replace("""attn""",       """self_attn"""				)
       if "proj" in name and "self_attn" in name and "text" not in name:
              A_						=      name.replace("""proj""",       """out_proj"""				)
       if "pre_assign_attn.attn.proj" in name:
              A_						=      name.replace("""pre_assign_attn.attn.proj""",       """pre_assign_attn.attn.out_proj"""				)
       if "norm1" in name:
              A_						=      name.replace("""norm1""",       """layer_norm1"""				)
       if "norm2" in name and "pre_assign" not in name:
              A_						=      name.replace("""norm2""",       """layer_norm2"""				)
       if "img_encoder.norm" in name:
              A_						=      name.replace("""img_encoder.norm""",       """vision_model.layernorm"""				)
       # text encoder
       if "text_encoder.token_embedding" in name:
              A_						=      name.replace("""text_encoder.token_embedding""",       """text_model.embeddings.token_embedding"""				)
       if "text_encoder.positional_embedding" in name:
              A_						=      name.replace("""text_encoder.positional_embedding""",       """text_model.embeddings.position_embedding.weight"""				)
       if "text_encoder.transformer.resblocks." in name:
              A_						=      name.replace("""text_encoder.transformer.resblocks.""",       """text_model.encoder.layers."""				)
       if "ln_1" in name:
              A_						=      name.replace("""ln_1""",       """layer_norm1"""				)
       if "ln_2" in name:
              A_						=      name.replace("""ln_2""",       """layer_norm2"""				)
       if "c_fc" in name:
              A_						=      name.replace("""c_fc""",       """fc1"""				)
       if "c_proj" in name:
              A_						=      name.replace("""c_proj""",       """fc2"""				)
       if "text_encoder" in name:
              A_						=      name.replace("""text_encoder""",       """text_model"""				)
       if "ln_final" in name:
              A_						=      name.replace("""ln_final""",       """final_layer_norm"""				)
       # projection layers
       if "img_projector.linear_hidden." in name:
              A_						=      name.replace("""img_projector.linear_hidden.""",       """visual_projection."""				)
       if "img_projector.linear_out." in name:
              A_						=      name.replace("""img_projector.linear_out.""",       """visual_projection.3."""				)
       if "text_projector.linear_hidden" in name:
              A_						=      name.replace("""text_projector.linear_hidden""",       """text_projection"""				)
       if "text_projector.linear_out" in name:
              A_						=      name.replace("""text_projector.linear_out""",       """text_projection.3"""				)

       return name
def       UpperCAmelCase__    (      UpperCAmelCase__,       UpperCAmelCase__				)			->			Any:
       for key in orig_state_dict.copy().keys():
              A_						=      orig_state_dict.pop(UpperCAmelCase__				)

              if "qkv" in key:
                     # weights and biases of the key, value and query projections of vision encoder's attention layers require special treatment:
                     # we need to split them up into separate matrices/vectors
                     A_						=      key.split("""."""				)
                     A_					,			A_						=      int(key_split[2]				), int(key_split[4]				)
                     A_						=      config.vision_config.hidden_size
                     if "weight" in key:
                            A_						=      val[:dim, :]
                            A_						=      val[dim : dim * 2, :]
                            A_						=      val[-dim:, :]
                     else:
                            A_						=      val[:dim]
                            A_						=      val[dim : dim * 2]
                            A_						=      val[-dim:]
              elif "in_proj" in key:
                     # weights and biases of the key, value and query projections of text encoder's attention layers require special treatment:
                     # we need to split them up into separate matrices/vectors
                     A_						=      key.split("""."""				)
                     A_						=      int(key_split[3]				)
                     A_						=      config.text_config.hidden_size
                     if "weight" in key:
                            A_						=      val[:dim, :]
                            A_						=      val[
                                dim : dim * 2, :
                            ]
                            A_						=      val[-dim:, :]
                     else:
                            A_						=      val[:dim]
                            A_						=      val[dim : dim * 2]
                            A_						=      val[-dim:]
              else:
                     A_						=      rename_key(UpperCAmelCase__				)
                     # squeeze if necessary
                     if (
                         "text_projection.0" in new_name
                         or "text_projection.3" in new_name
                         or "visual_projection.0" in new_name
                         or "visual_projection.3" in new_name
                     ):
                            A_						=      val.squeeze_()
                     else:
                            A_						=      val

       return orig_state_dict
def       UpperCAmelCase__    (      )			->			str:
       A_						=      """http://images.cocodataset.org/val2017/000000039769.jpg"""
       A_						=      Image.open(requests.get(UpperCAmelCase__,       stream=UpperCAmelCase__				).raw				)
       return im
@torch.no_grad()
def       UpperCAmelCase__    (      UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__="groupvit-gcc-yfcc",       UpperCAmelCase__=False				)			->			Any:
       A_						=      GroupViTConfig()
       A_						=      GroupViTModel(UpperCAmelCase__				).eval()

       A_						=      torch.load(UpperCAmelCase__,       map_location="""cpu"""				)["""model"""]
       A_						=      convert_state_dict(UpperCAmelCase__,       UpperCAmelCase__				)
       A_					,			A_						=      model.load_state_dict(UpperCAmelCase__,       strict=UpperCAmelCase__				)
       assert missing_keys == ["text_model.embeddings.position_ids"]
       assert (unexpected_keys == ["multi_label_logit_scale"]) or (len(UpperCAmelCase__				) == 0)

       # verify result
       A_						=      CLIPProcessor.from_pretrained("""openai/clip-vit-base-patch32"""				)
       A_						=      prepare_img()
       A_						=      processor(text=["""a photo of a cat""", """a photo of a dog"""],       images=UpperCAmelCase__,       padding=UpperCAmelCase__,       return_tensors="""pt"""				)

       with torch.no_grad():
              A_						=      model(**UpperCAmelCase__				)

       if model_name == "groupvit-gcc-yfcc":
              A_						=      torch.tensor([[13.3_523, 6.3_629]]				)
       elif model_name == "groupvit-gcc-redcaps":
              A_						=      torch.tensor([[16.1_873, 8.6_230]]				)
       else:
              raise ValueError(F'''Model name {model_name} not supported.'''				)
       assert torch.allclose(outputs.logits_per_image,       UpperCAmelCase__,       atol=1e-3				)

       processor.save_pretrained(UpperCAmelCase__				)
       model.save_pretrained(UpperCAmelCase__				)
       print("""Successfully saved processor and model to""",       UpperCAmelCase__				)

       if push_to_hub:
              print("""Pushing to the hub..."""				)
              processor.push_to_hub(UpperCAmelCase__,       organization="""nielsr"""				)
              model.push_to_hub(UpperCAmelCase__,       organization="""nielsr"""				)


if __name__ == "__main__":
      __lowerCamelCase		       =    argparse.ArgumentParser()
      parser.add_argument(
          '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to dump the processor and PyTorch model.'''
      )
      parser.add_argument('''--checkpoint_path''', default=None, type=str, help='''Path to GroupViT checkpoint''')
      parser.add_argument(
          '''--model_name''',
          default='''groupvit-gccy-fcc''',
          type=str,
          help='''Name of the model. Expecting either \'groupvit-gcc-yfcc\' or \'groupvit-gcc-redcaps\'''',
      )
      parser.add_argument(
          '''--push_to_hub''',
          action='''store_true''',
          help='''Whether or not to push the converted model and processor to the 🤗 hub using the provided `model_name`.''',
      )
      __lowerCamelCase		       =    parser.parse_args()

      convert_groupvit_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.model_name, args.push_to_hub)



'''simple docstring'''







__lowerCamelCase		       =    range(2, 20 + 1)
__lowerCamelCase		       =    [10**k for k in range(ks[-1] + 1)]
__lowerCamelCase		       =    {}
def       UpperCAmelCase__    (      UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__				)			->			Tuple:
       A_						=      sum(a_i[j] for j in range(UpperCAmelCase__,       len(UpperCAmelCase__				)				)				)
       A_						=      sum(a_i[j] * base[j] for j in range(min(len(UpperCAmelCase__				),       UpperCAmelCase__				)				)				)

       A_					,			A_						=      0, 0
       A_						=      n - i

       A_						=      memo.get(UpperCAmelCase__				)

       if sub_memo is not None:
              A_						=      sub_memo.get(UpperCAmelCase__				)

              if jumps is not None and len(UpperCAmelCase__				) > 0:
                     # find and make the largest jump without going over
                     A_						=      -1
                     for _k in range(len(UpperCAmelCase__				) - 1,       -1,       -1				):
                            if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
                                   A_						=      _k
                                   break

                     if max_jump >= 0:
                            A_					,			A_					,			A_						=      jumps[max_jump]
                            # since the difference between jumps is cached, add c
                            A_						=      diff + c
                            for j in range(min(UpperCAmelCase__,       len(UpperCAmelCase__				)				)				):
                                   A_					,			A_						=      divmod(UpperCAmelCase__,       10				)
                            if new_c > 0:
                                   add(UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__				)

              else:
                     A_						=      []
       else:
              A_						=      {c: []}
              A_						=      sub_memo

       if dn >= max_dn or c + diff >= base[k]:
              return diff, dn

       if k > ks[0]:
              while True:
                     # keep doing smaller jumps
                     A_					,			A_						=      next_term(UpperCAmelCase__,       k - 1,       i + dn,       UpperCAmelCase__				)
                     diff += _diff
                     dn += terms_jumped

                     if dn >= max_dn or c + diff >= base[k]:
                            break
       else:
              # would be too small a jump, just compute sequential terms instead
              A_					,			A_						=      compute(UpperCAmelCase__,       UpperCAmelCase__,       i + dn,       UpperCAmelCase__				)
              diff += _diff
              dn += terms_jumped

       A_						=      sub_memo[c]

       # keep jumps sorted by # of terms skipped
       A_						=      0
       while j < len(UpperCAmelCase__				):
              if jumps[j][1] > dn:
                     break
              j += 1

       # cache the jump for this value digitsum(b) and c
       sub_memo[c].insert(UpperCAmelCase__,       (diff, dn, k)				)
       return (diff, dn)
def       UpperCAmelCase__    (      UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__				)			->			int:
       if i >= n:
              return 0, i
       if k > len(UpperCAmelCase__				):
              a_i.extend([0 for _ in range(k - len(UpperCAmelCase__				)				)]				)

       # note: a_i -> b * 10^k + c
       # ds_b -> digitsum(b)
       # ds_c -> digitsum(c)
       A_						=      i
       A_					,			A_					,			A_						=      0, 0, 0
       for j in range(len(UpperCAmelCase__				)				):
              if j >= k:
                     ds_b += a_i[j]
              else:
                     ds_c += a_i[j]

       while i < n:
              i += 1
              A_						=      ds_c + ds_b
              diff += addend
              A_						=      0
              for j in range(UpperCAmelCase__				):
                     A_						=      a_i[j] + addend
                     A_					,			A_						=      divmod(UpperCAmelCase__,       10				)

                     ds_c += a_i[j]

              if addend > 0:
                     break

       if addend > 0:
              add(UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__				)
       return diff, i - start_i
def       UpperCAmelCase__    (      UpperCAmelCase__,       UpperCAmelCase__,       UpperCAmelCase__				)			->			str:
       for j in range(UpperCAmelCase__,       len(UpperCAmelCase__				)				):
              A_						=      digits[j] + addend
              if s >= 10:
                     A_					,			A_						=      divmod(UpperCAmelCase__,       10				)
                     A_						=      addend // 10 + quotient
              else:
                     A_						=      s
                     A_						=      addend // 10

              if addend == 0:
                     break

       while addend > 0:
              A_					,			A_						=      divmod(UpperCAmelCase__,       10				)
              digits.append(UpperCAmelCase__				)
def       UpperCAmelCase__    (      UpperCAmelCase__ = 10**15				)			->			int:
       A_						=      [1]
       A_						=      1
       A_						=      0
       while True:
              A_					,			A_						=      next_term(UpperCAmelCase__,       20,       i + dn,       UpperCAmelCase__				)
              dn += terms_jumped
              if dn == n - i:
                     break

       A_						=      0
       for j in range(len(UpperCAmelCase__				)				):
              a_n += digits[j] * 10**j
       return a_n


if __name__ == "__main__":
      print(f"""{solution() = }""")
