



"""simple docstring"""





import random

from .binary_exp_mod import bin_exp_mod
def        a__     (				lowerCAmelCase__     ,      lowerCAmelCase__=1000				):
      if n < 2:
            return False

      if n % 2 == 0:
            return n == 2

      # this means n is odd
      UpperCAmelCase_      			=							n - 1
      UpperCAmelCase_      			=							0
      while d % 2 == 0:
            d /= 2
            exp += 1

      # n - 1=d*(2**exp)
      UpperCAmelCase_      			=							0
      while count < prec:
            UpperCAmelCase_      			=							random.randint(2     ,      n - 1				)
            UpperCAmelCase_      			=							bin_exp_mod(lowerCAmelCase__     ,      lowerCAmelCase__     ,      lowerCAmelCase__				)
            if b != 1:
                  UpperCAmelCase_      			=							True
                  for _ in range(lowerCAmelCase__				):
                        if b == n - 1:
                              UpperCAmelCase_      			=							False
                              break
                        UpperCAmelCase_      			=							b * b
                        b %= n
                  if flag:
                        return False
                  count += 1
      return True


if __name__ == "__main__":
  lowerCamelCase       	=						abs(int(input("""Enter bound : """).strip()))
  print("""Here's the list of primes:""")
  print(""", """.join(str(i) for i in range(n + 1) if is_prime_big(i)))









"""simple docstring"""





import argparse

import gdown
import numpy as np
import torch
from huggingface_hub import hf_hub_download

from transformers import (
    CLIPTokenizer,
    CLIPTokenizerFast,
    VideoMAEImageProcessor,
    XCLIPConfig,
    XCLIPModel,
    XCLIPProcessor,
    XCLIPTextConfig,
    XCLIPVisionConfig,
)
def        a__     (				lowerCAmelCase__     ,      lowerCAmelCase__				):
      UpperCAmelCase_      			=							XCLIPTextConfig()

      # derive patch size from model name
      UpperCAmelCase_      			=							model_name.find("patch"				)
      UpperCAmelCase_      			=							int(model_name[start_idx + len("patch"				) : start_idx + len("patch"				) + 2]				)
      UpperCAmelCase_      			=							XCLIPVisionConfig(patch_size=lowerCAmelCase__     ,      num_frames=lowerCAmelCase__				)

      if "large" in model_name:
            UpperCAmelCase_      			=							768
            UpperCAmelCase_      			=							3072
            UpperCAmelCase_      			=							12

            UpperCAmelCase_      			=							1024
            UpperCAmelCase_      			=							4096
            UpperCAmelCase_      			=							16
            UpperCAmelCase_      			=							24
            UpperCAmelCase_      			=							768
            UpperCAmelCase_      			=							3072

      if model_name == "xclip-large-patch14-16-frames":
            UpperCAmelCase_      			=							336

      UpperCAmelCase_      			=							XCLIPConfig.from_text_vision_configs(lowerCAmelCase__     ,      lowerCAmelCase__				)

      if "large" in model_name:
            UpperCAmelCase_      			=							768

      return config
def        a__     (				lowerCAmelCase__				):
      # text encoder
      if name == "token_embedding.weight":
            UpperCAmelCase_      			=							name.replace("token_embedding.weight"     ,      "text_model.embeddings.token_embedding.weight"				)
      if name == "positional_embedding":
            UpperCAmelCase_      			=							name.replace("positional_embedding"     ,      "text_model.embeddings.position_embedding.weight"				)
      if "ln_1" in name:
            UpperCAmelCase_      			=							name.replace("ln_1"     ,      "layer_norm1"				)
      if "ln_2" in name:
            UpperCAmelCase_      			=							name.replace("ln_2"     ,      "layer_norm2"				)
      if "c_fc" in name:
            UpperCAmelCase_      			=							name.replace("c_fc"     ,      "fc1"				)
      if "c_proj" in name:
            UpperCAmelCase_      			=							name.replace("c_proj"     ,      "fc2"				)
      if name.startswith("transformer.resblocks"				):
            UpperCAmelCase_      			=							name.replace("transformer.resblocks"     ,      "text_model.encoder.layers"				)
      if "attn.out_proj" in name and "message" not in name:
            UpperCAmelCase_      			=							name.replace("attn.out_proj"     ,      "self_attn.out_proj"				)
      if "ln_final" in name:
            UpperCAmelCase_      			=							name.replace("ln_final"     ,      "text_model.final_layer_norm"				)
      # visual encoder
      if name == "visual.class_embedding":
            UpperCAmelCase_      			=							name.replace("visual.class_embedding"     ,      "vision_model.embeddings.class_embedding"				)
      if name == "visual.positional_embedding":
            UpperCAmelCase_      			=							name.replace("visual.positional_embedding"     ,      "vision_model.embeddings.position_embedding.weight"				)
      if name.startswith("visual.transformer.resblocks"				):
            UpperCAmelCase_      			=							name.replace("visual.transformer.resblocks"     ,      "vision_model.encoder.layers"				)
      if "visual.conv1" in name:
            UpperCAmelCase_      			=							name.replace("visual.conv1"     ,      "vision_model.embeddings.patch_embedding"				)
      if "visual.ln_pre" in name:
            UpperCAmelCase_      			=							name.replace("visual.ln_pre"     ,      "vision_model.pre_layernorm"				)
      if "visual.ln_post" in name:
            UpperCAmelCase_      			=							name.replace("visual.ln_post"     ,      "vision_model.post_layernorm"				)
      if "visual.proj" in name:
            UpperCAmelCase_      			=							name.replace("visual.proj"     ,      "visual_projection.weight"				)
      if "text_projection" in name:
            UpperCAmelCase_      			=							name.replace("text_projection"     ,      "text_projection.weight"				)
      # things on top
      if "prompts_visual_proj" in name:
            UpperCAmelCase_      			=							name.replace("prompts_visual_proj"     ,      "prompts_visual_projection"				)
      if "prompts_visual_ln" in name:
            UpperCAmelCase_      			=							name.replace("prompts_visual_ln"     ,      "prompts_visual_layernorm"				)
      # mit
      if name == "mit.positional_embedding":
            UpperCAmelCase_      			=							name.replace("positional"     ,      "position"				)
      if name.startswith("mit.resblocks"				):
            UpperCAmelCase_      			=							name.replace("mit.resblocks"     ,      "mit.encoder.layers"				)
      # prompts generator
      if name.startswith("prompts_generator.norm"				):
            UpperCAmelCase_      			=							name.replace("prompts_generator.norm"     ,      "prompts_generator.layernorm"				)

      return name
def        a__     (				lowerCAmelCase__     ,      lowerCAmelCase__				):
      for key in orig_state_dict.copy().keys():
            UpperCAmelCase_      			=							orig_state_dict.pop(lowerCAmelCase__				)

            if "attn.in_proj" in key:
                  UpperCAmelCase_      			=							key.split("."				)
                  if key.startswith("visual"				):
                        UpperCAmelCase_      			=							key_split[3]
                        UpperCAmelCase_      			=							config.vision_config.hidden_size
                        if "message_attn" in key:
                              if "weight" in key:
                                    UpperCAmelCase_      			=							val[
                                        :dim, :
                                    ]
                                    UpperCAmelCase_      			=							val[
                                        dim : dim * 2, :
                                    ]
                                    UpperCAmelCase_      			=							val[
                                        -dim:, :
                                    ]
                              else:
                                    UpperCAmelCase_      			=							val[
                                        :dim
                                    ]
                                    UpperCAmelCase_      			=							val[
                                        dim : dim * 2
                                    ]
                                    UpperCAmelCase_      			=							val[
                                        -dim:
                                    ]
                        else:
                              if "weight" in key:
                                    UpperCAmelCase_      			=							val[
                                        :dim, :
                                    ]
                                    UpperCAmelCase_      			=							val[
                                        dim : dim * 2, :
                                    ]
                                    UpperCAmelCase_      			=							val[
                                        -dim:, :
                                    ]
                              else:
                                    UpperCAmelCase_      			=							val[:dim]
                                    UpperCAmelCase_      			=							val[
                                        dim : dim * 2
                                    ]
                                    UpperCAmelCase_      			=							val[-dim:]
                  elif key.startswith("mit"				):
                        UpperCAmelCase_      			=							key_split[2]
                        UpperCAmelCase_      			=							config.vision_config.mit_hidden_size
                        if "weight" in key:
                              UpperCAmelCase_      			=							val[:dim, :]
                              UpperCAmelCase_      			=							val[dim : dim * 2, :]
                              UpperCAmelCase_      			=							val[-dim:, :]
                        else:
                              UpperCAmelCase_      			=							val[:dim]
                              UpperCAmelCase_      			=							val[dim : dim * 2]
                              UpperCAmelCase_      			=							val[-dim:]
                  else:
                        UpperCAmelCase_      			=							key_split[2]
                        UpperCAmelCase_      			=							config.text_config.hidden_size
                        if "weight" in key:
                              UpperCAmelCase_      			=							val[:dim, :]
                              UpperCAmelCase_      			=							val[
                                  dim : dim * 2, :
                              ]
                              UpperCAmelCase_      			=							val[-dim:, :]
                        else:
                              UpperCAmelCase_      			=							val[:dim]
                              UpperCAmelCase_      			=							val[
                                  dim : dim * 2
                              ]
                              UpperCAmelCase_      			=							val[-dim:]
            else:
                  UpperCAmelCase_      			=							rename_key(lowerCAmelCase__				)
                  if new_key_name in ["visual_projection.weight", "text_projection.weight"]:
                        UpperCAmelCase_      			=							val.T
                  UpperCAmelCase_      			=							val

      return orig_state_dict
def        a__     (				lowerCAmelCase__				):
      if num_frames == 8:
            UpperCAmelCase_      			=							"eating_spaghetti_8_frames.npy"
      elif num_frames == 16:
            UpperCAmelCase_      			=							"eating_spaghetti.npy"
      elif num_frames == 32:
            UpperCAmelCase_      			=							"eating_spaghetti_32_frames.npy"
      UpperCAmelCase_      			=							hf_hub_download(
          repo_id="hf-internal-testing/spaghetti-video"     ,      filename=lowerCAmelCase__     ,      repo_type="dataset"     ,      )
      UpperCAmelCase_      			=							np.load(lowerCAmelCase__				)
      return list(lowerCAmelCase__				)
def        a__     (				lowerCAmelCase__     ,      lowerCAmelCase__=None     ,      lowerCAmelCase__=False				):
      UpperCAmelCase_      			=							{
          # fully supervised kinetics-400 checkpoints
          "xclip-base-patch32": "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_8.pth",
          "xclip-base-patch32-16-frames": (
              "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_32_16.pth"
          ),
          "xclip-base-patch16": "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_8.pth",
          "xclip-base-patch16-16-frames": (
              "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k400_16_16.pth"
          ),
          "xclip-large-patch14": "https://drive.google.com/u/0/uc?id=1NUOImq0o5DlQTST17iIP3vG7DgmHQuCx&amp;export=download&amp;confirm=t&amp;uuid=b26caedc-88e2-473e-830a-9d158b653cdb",
          "xclip-large-patch14-16-frames": "https://drive.google.com/u/0/uc?id=1FOYgnJc097OJ4lGwtRCCydQyVPJEOH7d&amp;export=download&amp;confirm=t&amp;uuid=538fa810-e671-4050-b385-9a623f89804f",
          # fully supervised kinetics-600 checkpoints
          "xclip-base-patch16-kinetics-600": (
              "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_8.pth"
          ),
          "xclip-base-patch16-kinetics-600-16-frames": (
              "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/k600_16_16.pth"
          ),
          "xclip-large-patch14-kinetics-600": "https://drive.google.com/u/0/uc?id=1FV8C1INuM91sLAN4ImjzePLIlpMSihwV&amp;export=download&amp;confirm=t&amp;uuid=141d4977-4a65-44ae-864f-4b0c19f838be",
          # few shot
          "xclip-base-patch16-hmdb-2-shot": (
              "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_2.pth"
          ),
          "xclip-base-patch16-hmdb-4-shot": (
              "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_4.pth"
          ),
          "xclip-base-patch16-hmdb-8-shot": (
              "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_8.pth"
          ),
          "xclip-base-patch16-hmdb-16-shot": (
              "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_hmdb_16.pth"
          ),
          "xclip-base-patch16-ucf-2-shot": (
              "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_2.pth"
          ),
          "xclip-base-patch16-ucf-4-shot": (
              "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_4.pth"
          ),
          "xclip-base-patch16-ucf-8-shot": (
              "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_8.pth"
          ),
          "xclip-base-patch16-ucf-16-shot": (
              "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/few_ucf_16.pth"
          ),
          # zero shot
          "xclip-base-patch16-zero-shot": "https://github.com/nbl97/X-CLIP_Model_Zoo/releases/download/v1.0/zero.pth",
      }

      UpperCAmelCase_      			=							model_to_url[model_name]
      UpperCAmelCase_      			=							8
      if "16-frames" in model_name:
            UpperCAmelCase_      			=							16
      elif "shot" in model_name:
            UpperCAmelCase_      			=							32

      UpperCAmelCase_      			=							get_xclip_config(lowerCAmelCase__     ,      lowerCAmelCase__				)
      UpperCAmelCase_      			=							XCLIPModel(lowerCAmelCase__				)
      model.eval()

      if "drive" in checkpoint_url:
            UpperCAmelCase_      			=							"pytorch_model.bin"
            gdown.cached_download(lowerCAmelCase__     ,      lowerCAmelCase__     ,      quiet=lowerCAmelCase__				)
            UpperCAmelCase_      			=							torch.load(lowerCAmelCase__     ,      map_location="cpu"				)["model"]
      else:
            UpperCAmelCase_      			=							torch.hub.load_state_dict_from_url(lowerCAmelCase__				)["model"]

      UpperCAmelCase_      			=							convert_state_dict(lowerCAmelCase__     ,      lowerCAmelCase__				)

      UpperCAmelCase_      			=							XCLIPModel(lowerCAmelCase__				)
      UpperCAmelCase_			,   UpperCAmelCase_      			=							model.load_state_dict(lowerCAmelCase__     ,      strict=lowerCAmelCase__				)
      assert missing_keys == ["text_model.embeddings.position_ids", "vision_model.embeddings.position_ids"]
      model.eval()

      UpperCAmelCase_      			=							336 if model_name == "xclip-large-patch14-16-frames" else 224
      UpperCAmelCase_      			=							VideoMAEImageProcessor(size=lowerCAmelCase__				)
      UpperCAmelCase_      			=							CLIPTokenizer.from_pretrained("openai/clip-vit-base-patch32"				)
      UpperCAmelCase_      			=							CLIPTokenizerFast.from_pretrained("openai/clip-vit-base-patch32"				)
      UpperCAmelCase_      			=							XCLIPProcessor(image_processor=lowerCAmelCase__     ,      tokenizer=lowerCAmelCase__				)

      UpperCAmelCase_      			=							prepare_video(lowerCAmelCase__				)
      UpperCAmelCase_      			=							processor(
          text=["playing sports", "eating spaghetti", "go shopping"]     ,      videos=lowerCAmelCase__     ,      return_tensors="pt"     ,      padding=lowerCAmelCase__				)

      print("Shape of pixel values:"     ,      inputs.pixel_values.shape				)

      with torch.no_grad():
            UpperCAmelCase_      			=							model(**lowerCAmelCase__				)

      # Verify outputs
      UpperCAmelCase_      			=							outputs.logits_per_video
      UpperCAmelCase_      			=							logits_per_video.softmax(dim=1				)
      print("Probs:"     ,      lowerCAmelCase__				)
      # kinetics-400
      if model_name == "xclip-base-patch32":
            UpperCAmelCase_      			=							torch.tensor([[0.0019, 0.9951, 0.0030]]				)
      elif model_name == "xclip-base-patch32-16-frames":
            UpperCAmelCase_      			=							torch.tensor([[7.0999e-04, 9.9883e-01, 4.5580e-04]]				)
      elif model_name == "xclip-base-patch16":
            UpperCAmelCase_      			=							torch.tensor([[0.0083, 0.9681, 0.0236]]				)
      elif model_name == "xclip-base-patch16-16-frames":
            UpperCAmelCase_      			=							torch.tensor([[7.6937e-04, 9.9728e-01, 1.9473e-03]]				)
      elif model_name == "xclip-large-patch14":
            UpperCAmelCase_      			=							torch.tensor([[0.0062, 0.9864, 0.0075]]				)
      elif model_name == "xclip-large-patch14-16-frames":
            UpperCAmelCase_      			=							torch.tensor([[3.3877e-04, 9.9937e-01, 2.8888e-04]]				)
      # kinetics-600
      elif model_name == "xclip-base-patch16-kinetics-600":
            UpperCAmelCase_      			=							torch.tensor([[0.0555, 0.8914, 0.0531]]				)
      elif model_name == "xclip-base-patch16-kinetics-600-16-frames":
            UpperCAmelCase_      			=							torch.tensor([[3.8554e-04, 9.9929e-01, 3.2754e-04]]				)
      elif model_name == "xclip-large-patch14-kinetics-600":
            UpperCAmelCase_      			=							torch.tensor([[0.0036, 0.9920, 0.0045]]				)
      # few shot
      elif model_name == "xclip-base-patch16-hmdb-2-shot":
            UpperCAmelCase_      			=							torch.tensor([[7.1890e-06, 9.9994e-01, 5.6559e-05]]				)
      elif model_name == "xclip-base-patch16-hmdb-4-shot":
            UpperCAmelCase_      			=							torch.tensor([[1.0320e-05, 9.9993e-01, 6.2435e-05]]				)
      elif model_name == "xclip-base-patch16-hmdb-8-shot":
            UpperCAmelCase_      			=							torch.tensor([[4.1377e-06, 9.9990e-01, 9.8386e-05]]				)
      elif model_name == "xclip-base-patch16-hmdb-16-shot":
            UpperCAmelCase_      			=							torch.tensor([[4.1347e-05, 9.9962e-01, 3.3411e-04]]				)
      elif model_name == "xclip-base-patch16-ucf-2-shot":
            UpperCAmelCase_      			=							torch.tensor([[8.5857e-05, 9.9928e-01, 6.3291e-04]]				)
      elif model_name == "xclip-base-patch16-ucf-4-shot":
            UpperCAmelCase_      			=							torch.tensor([[8.5857e-05, 9.9928e-01, 6.3291e-04]]				)
      elif model_name == "xclip-base-patch16-ucf-8-shot":
            UpperCAmelCase_      			=							torch.tensor([[0.0027, 0.9904, 0.0070]]				)
      elif model_name == "xclip-base-patch16-ucf-16-shot":
            UpperCAmelCase_      			=							torch.tensor([[9.8219e-04, 9.9593e-01, 3.0863e-03]]				)
      # zero shot
      elif model_name == "xclip-base-patch16-zero-shot":
            UpperCAmelCase_      			=							torch.tensor([[3.5082e-04, 9.9785e-01, 1.7966e-03]]				)
      else:
            raise ValueError(f"""Model name {model_name} not supported"""				)
      assert torch.allclose(lowerCAmelCase__     ,      lowerCAmelCase__     ,      atol=1e-3				)
      print("Looks ok!"				)

      if pytorch_dump_folder_path is not None:
            print(f"""Saving model {model_name} to {pytorch_dump_folder_path}"""				)
            model.save_pretrained(lowerCAmelCase__				)

      if push_to_hub:
            print("Pushing model, processor and slow tokenizer files to the hub..."				)
            model.push_to_hub(lowerCAmelCase__     ,      organization="nielsr"				)
            processor.push_to_hub(lowerCAmelCase__     ,      organization="nielsr"				)
            slow_tokenizer.push_to_hub(lowerCAmelCase__     ,      organization="nielsr"				)


if __name__ == "__main__":
  lowerCamelCase       	=						argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      """--model_name""",
      default="""xclip-base-patch32""",
      type=str,
      help="""Name of the model.""",
  )
  parser.add_argument(
      """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
  )
  parser.add_argument(
      """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub."""
  )

  lowerCamelCase       	=						parser.parse_args()
  convert_xclip_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




