import math
from datetime import datetime, timedelta


def    a__       (						__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     year % 1_9
      SCREAMING_SNAKE_CASE_      =     year % 4
      SCREAMING_SNAKE_CASE_      =     year % 7
      SCREAMING_SNAKE_CASE_      =     math.floor(year / 1_0_0 )
      SCREAMING_SNAKE_CASE_      =     math.floor((1_3 + 8 * leap_day_inhibits) / 2_5 )
      SCREAMING_SNAKE_CASE_      =     leap_day_inhibits / 4
      SCREAMING_SNAKE_CASE_      =     (
          1_5 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
      ) % 3_0
      SCREAMING_SNAKE_CASE_      =     (4 + leap_day_inhibits - leap_day_reinstall_number) % 7

      # days to be added to March 21
      SCREAMING_SNAKE_CASE_      =     (1_9 * metonic_cycle + secular_moon_shift) % 3_0

      # PHM -> Paschal Full Moon
      SCREAMING_SNAKE_CASE_      =     (
          2 * julian_leap_year
          + 4 * non_leap_year
          + 6 * days_to_add
          + century_starting_point
      ) % 7

      if days_to_add == 2_9 and days_from_phm_to_sunday == 6:
            return datetime(__UpperCamelCase   ,					4   ,					1_9 )
      elif days_to_add == 2_8 and days_from_phm_to_sunday == 6:
            return datetime(__UpperCamelCase   ,					4   ,					1_8 )
      else:
            return datetime(__UpperCamelCase   ,					3   ,					2_2 ) + timedelta(
                days=int(days_to_add + days_from_phm_to_sunday ) )


if __name__ == "__main__":
      for year in (19_94, 20_00, 20_10, 20_21, 20_23):
            A   :     Dict       =				"will be" if year > datetime.now().year else "was"
            print(f"Easter in {year} {tense} {gauss_easter(year)}")



import argparse
import json
from pathlib import Path

import requests
import timm
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import DeiTConfig, DeiTForImageClassificationWithTeacher, DeiTImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
A   :     str       =				logging.get_logger(__name__)


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase=False ):
      SCREAMING_SNAKE_CASE_      =     []
      for i in range(config.num_hidden_layers ):
            # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
            rename_keys.append((F'''blocks.{i}.norm1.weight''', F'''deit.encoder.layer.{i}.layernorm_before.weight''') )
            rename_keys.append((F'''blocks.{i}.norm1.bias''', F'''deit.encoder.layer.{i}.layernorm_before.bias''') )
            rename_keys.append((F'''blocks.{i}.attn.proj.weight''', F'''deit.encoder.layer.{i}.attention.output.dense.weight''') )
            rename_keys.append((F'''blocks.{i}.attn.proj.bias''', F'''deit.encoder.layer.{i}.attention.output.dense.bias''') )
            rename_keys.append((F'''blocks.{i}.norm2.weight''', F'''deit.encoder.layer.{i}.layernorm_after.weight''') )
            rename_keys.append((F'''blocks.{i}.norm2.bias''', F'''deit.encoder.layer.{i}.layernorm_after.bias''') )
            rename_keys.append((F'''blocks.{i}.mlp.fc1.weight''', F'''deit.encoder.layer.{i}.intermediate.dense.weight''') )
            rename_keys.append((F'''blocks.{i}.mlp.fc1.bias''', F'''deit.encoder.layer.{i}.intermediate.dense.bias''') )
            rename_keys.append((F'''blocks.{i}.mlp.fc2.weight''', F'''deit.encoder.layer.{i}.output.dense.weight''') )
            rename_keys.append((F'''blocks.{i}.mlp.fc2.bias''', F'''deit.encoder.layer.{i}.output.dense.bias''') )

      # projection layer + position embeddings
      rename_keys.extend(
          [
              ("cls_token", "deit.embeddings.cls_token"),
              ("dist_token", "deit.embeddings.distillation_token"),
              ("patch_embed.proj.weight", "deit.embeddings.patch_embeddings.projection.weight"),
              ("patch_embed.proj.bias", "deit.embeddings.patch_embeddings.projection.bias"),
              ("pos_embed", "deit.embeddings.position_embeddings"),
          ] )

      if base_model:
            # layernorm + pooler
            rename_keys.extend(
                [
                    ("norm.weight", "layernorm.weight"),
                    ("norm.bias", "layernorm.bias"),
                    ("pre_logits.fc.weight", "pooler.dense.weight"),
                    ("pre_logits.fc.bias", "pooler.dense.bias"),
                ] )

            # if just the base model, we should remove "deit" from all keys that start with "deit"
            SCREAMING_SNAKE_CASE_      =     [(pair[0], pair[1][4:]) if pair[1].startswith("deit" ) else pair for pair in rename_keys]
      else:
            # layernorm + classification heads
            rename_keys.extend(
                [
                    ("norm.weight", "deit.layernorm.weight"),
                    ("norm.bias", "deit.layernorm.bias"),
                    ("head.weight", "cls_classifier.weight"),
                    ("head.bias", "cls_classifier.bias"),
                    ("head_dist.weight", "distillation_classifier.weight"),
                    ("head_dist.bias", "distillation_classifier.bias"),
                ] )

      return rename_keys


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase=False ):
      for i in range(config.num_hidden_layers ):
            if base_model:
                  SCREAMING_SNAKE_CASE_      =     ""
            else:
                  SCREAMING_SNAKE_CASE_      =     "deit."
            # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
            SCREAMING_SNAKE_CASE_      =     state_dict.pop(F'''blocks.{i}.attn.qkv.weight''' )
            SCREAMING_SNAKE_CASE_      =     state_dict.pop(F'''blocks.{i}.attn.qkv.bias''' )
            # next, add query, keys and values (in that order) to the state dict
            SCREAMING_SNAKE_CASE_      =     in_proj_weight[
                : config.hidden_size, :
            ]
            SCREAMING_SNAKE_CASE_      =     in_proj_bias[: config.hidden_size]
            SCREAMING_SNAKE_CASE_      =     in_proj_weight[
                config.hidden_size : config.hidden_size * 2, :
            ]
            SCREAMING_SNAKE_CASE_      =     in_proj_bias[
                config.hidden_size : config.hidden_size * 2
            ]
            SCREAMING_SNAKE_CASE_      =     in_proj_weight[
                -config.hidden_size :, :
            ]
            SCREAMING_SNAKE_CASE_      =     in_proj_bias[-config.hidden_size :]


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     dct.pop(__UpperCamelCase )
      SCREAMING_SNAKE_CASE_      =     val


def    a__       (						):
      SCREAMING_SNAKE_CASE_      =     "http://images.cocodataset.org/val2017/000000039769.jpg"
      SCREAMING_SNAKE_CASE_      =     Image.open(requests.get(__UpperCamelCase   ,					stream=__UpperCamelCase ).raw )
      return im


@torch.no_grad()
def    a__       (						__UpperCamelCase   ,					__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     DeiTConfig()
      # all deit models have fine-tuned heads
      SCREAMING_SNAKE_CASE_      =     False
      # dataset (fine-tuned on ImageNet 2012), patch_size and image_size
      SCREAMING_SNAKE_CASE_      =     1_0_0_0
      SCREAMING_SNAKE_CASE_      =     "huggingface/label-files"
      SCREAMING_SNAKE_CASE_      =     "imagenet-1k-id2label.json"
      SCREAMING_SNAKE_CASE_      =     json.load(open(hf_hub_download(__UpperCamelCase   ,					__UpperCamelCase   ,					repo_type="dataset" )   ,					"r" ) )
      SCREAMING_SNAKE_CASE_      =     {int(__UpperCamelCase ): v for k, v in idalabel.items()}
      SCREAMING_SNAKE_CASE_      =     idalabel
      SCREAMING_SNAKE_CASE_      =     {v: k for k, v in idalabel.items()}
      SCREAMING_SNAKE_CASE_      =     int(deit_name[-6:-4] )
      SCREAMING_SNAKE_CASE_      =     int(deit_name[-3:] )
      # size of the architecture
      if deit_name[9:].startswith("tiny" ):
            SCREAMING_SNAKE_CASE_      =     1_9_2
            SCREAMING_SNAKE_CASE_      =     7_6_8
            SCREAMING_SNAKE_CASE_      =     1_2
            SCREAMING_SNAKE_CASE_      =     3
      elif deit_name[9:].startswith("small" ):
            SCREAMING_SNAKE_CASE_      =     3_8_4
            SCREAMING_SNAKE_CASE_      =     1_5_3_6
            SCREAMING_SNAKE_CASE_      =     1_2
            SCREAMING_SNAKE_CASE_      =     6
      if deit_name[9:].startswith("base" ):
            pass
      elif deit_name[4:].startswith("large" ):
            SCREAMING_SNAKE_CASE_      =     1_0_2_4
            SCREAMING_SNAKE_CASE_      =     4_0_9_6
            SCREAMING_SNAKE_CASE_      =     2_4
            SCREAMING_SNAKE_CASE_      =     1_6

      # load original model from timm
      SCREAMING_SNAKE_CASE_      =     timm.create_model(__UpperCamelCase   ,					pretrained=__UpperCamelCase )
      timm_model.eval()

      # load state_dict of original model, remove and rename some keys
      SCREAMING_SNAKE_CASE_      =     timm_model.state_dict()
      SCREAMING_SNAKE_CASE_      =     create_rename_keys(__UpperCamelCase   ,					__UpperCamelCase )
      for src, dest in rename_keys:
            rename_key(__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase )
      read_in_q_k_v(__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase )

      # load HuggingFace model
      SCREAMING_SNAKE_CASE_      =     DeiTForImageClassificationWithTeacher(__UpperCamelCase ).eval()
      model.load_state_dict(__UpperCamelCase )

      # Check outputs on an image, prepared by DeiTImageProcessor
      SCREAMING_SNAKE_CASE_      =     int(
          (2_5_6 / 2_2_4) * config.image_size )  # to maintain same ratio w.r.t. 224 images, see https://github.com/facebookresearch/deit/blob/ab5715372db8c6cad5740714b2216d55aeae052e/datasets.py#L103
      SCREAMING_SNAKE_CASE_      =     DeiTImageProcessor(size=__UpperCamelCase   ,					crop_size=config.image_size )
      SCREAMING_SNAKE_CASE_      =     image_processor(images=prepare_img()   ,					return_tensors="pt" )
      SCREAMING_SNAKE_CASE_      =     encoding["pixel_values"]
      SCREAMING_SNAKE_CASE_      =     model(__UpperCamelCase )

      SCREAMING_SNAKE_CASE_      =     timm_model(__UpperCamelCase )
      assert timm_logits.shape == outputs.logits.shape
      assert torch.allclose(__UpperCamelCase   ,					outputs.logits   ,					atol=1E-3 )

      Path(__UpperCamelCase ).mkdir(exist_ok=__UpperCamelCase )
      print(F'''Saving model {deit_name} to {pytorch_dump_folder_path}''' )
      model.save_pretrained(__UpperCamelCase )
      print(F'''Saving image processor to {pytorch_dump_folder_path}''' )
      image_processor.save_pretrained(__UpperCamelCase )


if __name__ == "__main__":
      A   :     Tuple       =				argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          "--deit_name",
          default="vit_deit_base_distilled_patch16_224",
          type=str,
          help="Name of the DeiT timm model you'd like to convert.",
      )
      parser.add_argument(
          "--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model directory."
      )

      A   :     Dict       =				parser.parse_args()
      convert_deit_checkpoint(args.deit_name, args.pytorch_dump_folder_path)


