


"""simple docstring"""
import argparse
import json
from pathlib import Path

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

from transformers import DetrConfig, DetrForObjectDetection, DetrForSegmentation, DetrImageProcessor, ResNetConfig
from transformers.utils import logging


logging.set_verbosity_info()
UpperCAmelCase				=						logging.get_logger(__name__)

def 				_snake_case      (   __snake_case							:      Optional[Any]   ):




   """simple docstring"""







   if "resnet-50" in model_name:
      _lowerCamelCase	:					Optional[Any]   =		ResNetConfig.from_pretrained("""microsoft/resnet-50"""   )
   elif "resnet-101" in model_name:
      _lowerCamelCase	:					Any   =		ResNetConfig.from_pretrained("""microsoft/resnet-101"""   )
   else:
      raise ValueError("""Model name should include either resnet50 or resnet101"""   )

   _lowerCamelCase	:					Union[str, Any]   =		DetrConfig(use_timm_backbone=__snake_case						, backbone_config=__snake_case   )

   # set label attributes
   _lowerCamelCase	:					List[Any]   =		"""panoptic""" in model_name
   if is_panoptic:
      _lowerCamelCase	:					str   =		250
   else:
      _lowerCamelCase	:					str   =		91
      _lowerCamelCase	:					int   =		"""huggingface/label-files"""
      _lowerCamelCase	:					int   =		"""coco-detection-id2label.json"""
      _lowerCamelCase	:					Tuple   =		json.load(open(hf_hub_download(__snake_case						, __snake_case						, repo_type="""dataset"""   )						, """r"""   )   )
      _lowerCamelCase	:					Optional[int]   =		{int(__snake_case   ): v for k, v in idalabel.items()}
      _lowerCamelCase	:					int   =		idalabel
      _lowerCamelCase	:					Dict   =		{v: k for k, v in idalabel.items()}

   return config, is_panoptic

def 				_snake_case      (   __snake_case							:      Optional[Any]   ):




   """simple docstring"""







   _lowerCamelCase	:					Any   =		[]

   # stem
   # fmt: off
   rename_keys.append(("""backbone.0.body.conv1.weight""", """backbone.conv_encoder.model.embedder.embedder.convolution.weight""")   )
   rename_keys.append(("""backbone.0.body.bn1.weight""", """backbone.conv_encoder.model.embedder.embedder.normalization.weight""")   )
   rename_keys.append(("""backbone.0.body.bn1.bias""", """backbone.conv_encoder.model.embedder.embedder.normalization.bias""")   )
   rename_keys.append(("""backbone.0.body.bn1.running_mean""", """backbone.conv_encoder.model.embedder.embedder.normalization.running_mean""")   )
   rename_keys.append(("""backbone.0.body.bn1.running_var""", """backbone.conv_encoder.model.embedder.embedder.normalization.running_var""")   )
   # stages
   for stage_idx in range(len(config.backbone_config.depths   )   ):
      for layer_idx in range(config.backbone_config.depths[stage_idx]   ):
         # shortcut
         if layer_idx == 0:
            rename_keys.append(
                (
                    F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.0.weight',
                    F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.convolution.weight',
                )   )
            rename_keys.append(
                (
                    F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.weight',
                    F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.weight',
                )   )
            rename_keys.append(
                (
                    F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.bias',
                    F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.bias',
                )   )
            rename_keys.append(
                (
                    F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_mean',
                    F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_mean',
                )   )
            rename_keys.append(
                (
                    F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.downsample.1.running_var',
                    F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.shortcut.normalization.running_var',
                )   )
         # 3 convs
         for i in range(3   ):
            rename_keys.append(
                (
                    F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.conv{i+1}.weight',
                    F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.convolution.weight',
                )   )
            rename_keys.append(
                (
                    F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.weight',
                    F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.weight',
                )   )
            rename_keys.append(
                (
                    F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.bias',
                    F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.bias',
                )   )
            rename_keys.append(
                (
                    F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_mean',
                    F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_mean',
                )   )
            rename_keys.append(
                (
                    F'backbone.0.body.layer{stage_idx + 1}.{layer_idx}.bn{i+1}.running_var',
                    F'backbone.conv_encoder.model.encoder.stages.{stage_idx}.layers.{layer_idx}.layer.{i}.normalization.running_var',
                )   )
    # fmt: on

   for i in range(config.encoder_layers   ):
      # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
      rename_keys.append(
          (
              F'transformer.encoder.layers.{i}.self_attn.out_proj.weight',
              F'encoder.layers.{i}.self_attn.out_proj.weight',
          )   )
      rename_keys.append(
          (F'transformer.encoder.layers.{i}.self_attn.out_proj.bias', F'encoder.layers.{i}.self_attn.out_proj.bias')   )
      rename_keys.append((F'transformer.encoder.layers.{i}.linear1.weight', F'encoder.layers.{i}.fc1.weight')   )
      rename_keys.append((F'transformer.encoder.layers.{i}.linear1.bias', F'encoder.layers.{i}.fc1.bias')   )
      rename_keys.append((F'transformer.encoder.layers.{i}.linear2.weight', F'encoder.layers.{i}.fc2.weight')   )
      rename_keys.append((F'transformer.encoder.layers.{i}.linear2.bias', F'encoder.layers.{i}.fc2.bias')   )
      rename_keys.append(
          (F'transformer.encoder.layers.{i}.norm1.weight', F'encoder.layers.{i}.self_attn_layer_norm.weight')   )
      rename_keys.append(
          (F'transformer.encoder.layers.{i}.norm1.bias', F'encoder.layers.{i}.self_attn_layer_norm.bias')   )
      rename_keys.append(
          (F'transformer.encoder.layers.{i}.norm2.weight', F'encoder.layers.{i}.final_layer_norm.weight')   )
      rename_keys.append((F'transformer.encoder.layers.{i}.norm2.bias', F'encoder.layers.{i}.final_layer_norm.bias')   )
      # decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
      rename_keys.append(
          (
              F'transformer.decoder.layers.{i}.self_attn.out_proj.weight',
              F'decoder.layers.{i}.self_attn.out_proj.weight',
          )   )
      rename_keys.append(
          (F'transformer.decoder.layers.{i}.self_attn.out_proj.bias', F'decoder.layers.{i}.self_attn.out_proj.bias')   )
      rename_keys.append(
          (
              F'transformer.decoder.layers.{i}.multihead_attn.out_proj.weight',
              F'decoder.layers.{i}.encoder_attn.out_proj.weight',
          )   )
      rename_keys.append(
          (
              F'transformer.decoder.layers.{i}.multihead_attn.out_proj.bias',
              F'decoder.layers.{i}.encoder_attn.out_proj.bias',
          )   )
      rename_keys.append((F'transformer.decoder.layers.{i}.linear1.weight', F'decoder.layers.{i}.fc1.weight')   )
      rename_keys.append((F'transformer.decoder.layers.{i}.linear1.bias', F'decoder.layers.{i}.fc1.bias')   )
      rename_keys.append((F'transformer.decoder.layers.{i}.linear2.weight', F'decoder.layers.{i}.fc2.weight')   )
      rename_keys.append((F'transformer.decoder.layers.{i}.linear2.bias', F'decoder.layers.{i}.fc2.bias')   )
      rename_keys.append(
          (F'transformer.decoder.layers.{i}.norm1.weight', F'decoder.layers.{i}.self_attn_layer_norm.weight')   )
      rename_keys.append(
          (F'transformer.decoder.layers.{i}.norm1.bias', F'decoder.layers.{i}.self_attn_layer_norm.bias')   )
      rename_keys.append(
          (F'transformer.decoder.layers.{i}.norm2.weight', F'decoder.layers.{i}.encoder_attn_layer_norm.weight')   )
      rename_keys.append(
          (F'transformer.decoder.layers.{i}.norm2.bias', F'decoder.layers.{i}.encoder_attn_layer_norm.bias')   )
      rename_keys.append(
          (F'transformer.decoder.layers.{i}.norm3.weight', F'decoder.layers.{i}.final_layer_norm.weight')   )
      rename_keys.append((F'transformer.decoder.layers.{i}.norm3.bias', F'decoder.layers.{i}.final_layer_norm.bias')   )

   # convolutional projection + query embeddings + layernorm of decoder + class and bounding box heads
   rename_keys.extend(
       [
           ("""input_proj.weight""", """input_projection.weight"""),
           ("""input_proj.bias""", """input_projection.bias"""),
           ("""query_embed.weight""", """query_position_embeddings.weight"""),
           ("""transformer.decoder.norm.weight""", """decoder.layernorm.weight"""),
           ("""transformer.decoder.norm.bias""", """decoder.layernorm.bias"""),
           ("""class_embed.weight""", """class_labels_classifier.weight"""),
           ("""class_embed.bias""", """class_labels_classifier.bias"""),
           ("""bbox_embed.layers.0.weight""", """bbox_predictor.layers.0.weight"""),
           ("""bbox_embed.layers.0.bias""", """bbox_predictor.layers.0.bias"""),
           ("""bbox_embed.layers.1.weight""", """bbox_predictor.layers.1.weight"""),
           ("""bbox_embed.layers.1.bias""", """bbox_predictor.layers.1.bias"""),
           ("""bbox_embed.layers.2.weight""", """bbox_predictor.layers.2.weight"""),
           ("""bbox_embed.layers.2.bias""", """bbox_predictor.layers.2.bias"""),
       ]   )

   return rename_keys

def 				_snake_case      (   __snake_case							:      List[str]						, __snake_case							:      Dict						, __snake_case							:      int   ):




   """simple docstring"""







   _lowerCamelCase	:					Optional[Any]   =		state_dict.pop(__snake_case   )
   _lowerCamelCase	:					Any   =		val

def 				_snake_case      (   __snake_case							:      Optional[int]						, __snake_case							:      Any=False   ):




   """simple docstring"""







   _lowerCamelCase	:					str   =		""""""
   if is_panoptic:
      _lowerCamelCase	:					Dict   =		"""detr."""

   # first: transformer encoder
   for i in range(6   ):
      # read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
      _lowerCamelCase	:					int   =		state_dict.pop(F'{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight'   )
      _lowerCamelCase	:					List[Any]   =		state_dict.pop(F'{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias'   )
      # next, add query, keys and values (in that order) to the state dict
      _lowerCamelCase	:					Dict   =		in_proj_weight[:256, :]
      _lowerCamelCase	:					Optional[Any]   =		in_proj_bias[:256]
      _lowerCamelCase	:					str   =		in_proj_weight[256:512, :]
      _lowerCamelCase	:					List[str]   =		in_proj_bias[256:512]
      _lowerCamelCase	:					Union[str, Any]   =		in_proj_weight[-256:, :]
      _lowerCamelCase	:					Union[str, Any]   =		in_proj_bias[-256:]
   # next: transformer decoder (which is a bit more complex because it also includes cross-attention)
   for i in range(6   ):
      # read in weights + bias of input projection layer of self-attention
      _lowerCamelCase	:					Optional[int]   =		state_dict.pop(F'{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight'   )
      _lowerCamelCase	:					Optional[Any]   =		state_dict.pop(F'{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias'   )
      # next, add query, keys and values (in that order) to the state dict
      _lowerCamelCase	:					Optional[Any]   =		in_proj_weight[:256, :]
      _lowerCamelCase	:					Optional[int]   =		in_proj_bias[:256]
      _lowerCamelCase	:					Optional[Any]   =		in_proj_weight[256:512, :]
      _lowerCamelCase	:					Any   =		in_proj_bias[256:512]
      _lowerCamelCase	:					Optional[Any]   =		in_proj_weight[-256:, :]
      _lowerCamelCase	:					Any   =		in_proj_bias[-256:]
      # read in weights + bias of input projection layer of cross-attention
      _lowerCamelCase	:					str   =		state_dict.pop(
          F'{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight'   )
      _lowerCamelCase	:					str   =		state_dict.pop(F'{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias'   )
      # next, add query, keys and values (in that order) of cross-attention to the state dict
      _lowerCamelCase	:					List[Any]   =		in_proj_weight_cross_attn[:256, :]
      _lowerCamelCase	:					int   =		in_proj_bias_cross_attn[:256]
      _lowerCamelCase	:					int   =		in_proj_weight_cross_attn[256:512, :]
      _lowerCamelCase	:					str   =		in_proj_bias_cross_attn[256:512]
      _lowerCamelCase	:					Dict   =		in_proj_weight_cross_attn[-256:, :]
      _lowerCamelCase	:					Any   =		in_proj_bias_cross_attn[-256:]

def 				_snake_case      (   ):




   """simple docstring"""







   _lowerCamelCase	:					Optional[Any]   =		"""http://images.cocodataset.org/val2017/000000039769.jpg"""
   _lowerCamelCase	:					Union[str, Any]   =		Image.open(requests.get(__snake_case						, stream=__snake_case   ).raw   )

   return im

@torch.no_grad()
def 				_snake_case      (   __snake_case							:      int						, __snake_case							:      List[str]=None						, __snake_case							:      int=False   ):




   """simple docstring"""







   _lowerCamelCase   ,    _lowerCamelCase	:					Tuple   =		get_detr_config(__snake_case   )

   # load original model from torch hub
   _lowerCamelCase	:					int   =		{
       """detr-resnet-50""": """detr_resnet50""",
       """detr-resnet-101""": """detr_resnet101""",
   }
   logger.info(F'Converting model {model_name}...'   )
   _lowerCamelCase	:					List[str]   =		torch.hub.load("""facebookresearch/detr"""						, model_name_to_original_name[model_name]						, pretrained=__snake_case   ).eval()
   _lowerCamelCase	:					Tuple   =		detr.state_dict()
   # rename keys
   for src, dest in create_rename_keys(__snake_case   ):
      if is_panoptic:
         _lowerCamelCase	:					str   =		"""detr.""" + src
      rename_key(__snake_case						, __snake_case						, __snake_case   )
   # query, key and value matrices need special treatment
   read_in_q_k_v(__snake_case						, is_panoptic=__snake_case   )
   # important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
   _lowerCamelCase	:					Optional[Any]   =		"""detr.model.""" if is_panoptic else """model."""
   for key in state_dict.copy().keys():
      if is_panoptic:
         if (
             key.startswith("""detr"""   )
             and not key.startswith("""class_labels_classifier"""   )
             and not key.startswith("""bbox_predictor"""   )
         ):
            _lowerCamelCase	:					Union[str, Any]   =		state_dict.pop(__snake_case   )
            _lowerCamelCase	:					Dict   =		val
         elif "class_labels_classifier" in key or "bbox_predictor" in key:
            _lowerCamelCase	:					int   =		state_dict.pop(__snake_case   )
            _lowerCamelCase	:					int   =		val
         elif key.startswith("""bbox_attention"""   ) or key.startswith("""mask_head"""   ):
            continue
         else:
            _lowerCamelCase	:					Any   =		state_dict.pop(__snake_case   )
            _lowerCamelCase	:					int   =		val
      else:
         if not key.startswith("""class_labels_classifier"""   ) and not key.startswith("""bbox_predictor"""   ):
            _lowerCamelCase	:					Optional[int]   =		state_dict.pop(__snake_case   )
            _lowerCamelCase	:					str   =		val

    # finally, create HuggingFace model and load state dict
   _lowerCamelCase	:					Tuple   =		DetrForSegmentation(__snake_case   ) if is_panoptic else DetrForObjectDetection(__snake_case   )
   model.load_state_dict(__snake_case   )
   model.eval()

   # verify our conversion on an image
   _lowerCamelCase	:					int   =		"""coco_panoptic""" if is_panoptic else """coco_detection"""
   _lowerCamelCase	:					List[Any]   =		DetrImageProcessor(format=__snake_case   )

   _lowerCamelCase	:					Optional[int]   =		processor(images=prepare_img()						, return_tensors="""pt"""   )
   _lowerCamelCase	:					Union[str, Any]   =		encoding["""pixel_values"""]

   _lowerCamelCase	:					Union[str, Any]   =		detr(__snake_case   )
   _lowerCamelCase	:					Any   =		model(__snake_case   )

   assert torch.allclose(outputs.logits						, original_outputs["""pred_logits"""]						, atol=1E-3   )
   assert torch.allclose(outputs.pred_boxes						, original_outputs["""pred_boxes"""]						, atol=1E-3   )
   if is_panoptic:
      assert torch.allclose(outputs.pred_masks						, original_outputs["""pred_masks"""]						, atol=1E-4   )
   print("""Looks ok!"""   )

   if pytorch_dump_folder_path is not None:
      # Save model and image processor
      logger.info(F'Saving PyTorch model and image processor to {pytorch_dump_folder_path}...'   )
      Path(__snake_case   ).mkdir(exist_ok=__snake_case   )
      model.save_pretrained(__snake_case   )
      processor.save_pretrained(__snake_case   )

   if push_to_hub:
      # Upload model and image processor to the hub
      logger.info("""Uploading PyTorch model and image processor to the hub..."""   )
      model.push_to_hub(F'nielsr/{model_name}'   )
      processor.push_to_hub(F'nielsr/{model_name}'   )


if __name__ == "__main__":
 UpperCAmelCase				=						argparse.ArgumentParser()

 parser.add_argument(
     """--model_name""",
     default="""detr-resnet-50""",
     type=str,
     choices=["""detr-resnet-50""", """detr-resnet-101"""],
     help="""Name of the DETR model you'd like to convert.""",
 )
 parser.add_argument(
     """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the folder to output PyTorch model."""
 )
 parser.add_argument("""--push_to_hub""", action="""store_true""", help="""Whether to push the model to the hub or not.""")
 UpperCAmelCase				=						parser.parse_args()
 convert_detr_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







"""simple docstring"""

import math
from datetime import datetime, timedelta






def 		_snake_case	(   _snake_case				:   int				)       ->   datetime:






      '''simple docstring'''


      _A     =  year % 19
      _A     =  year % 4
      _A     =  year % 7
      _A     =  math.floor(year / 1_00				)
      _A     =  math.floor((13 + 8 * leap_day_inhibits) / 25				)
      _A     =  leap_day_inhibits / 4
      _A     =  (
          15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
      ) % 30
      _A     =  (4 + leap_day_inhibits - leap_day_reinstall_number) % 7

      # days to be added to March 21
      _A     =  (19 * metonic_cycle + secular_moon_shift) % 30

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

      if days_to_add == 29 and days_from_phm_to_sunday == 6:
            return datetime(_snake_case							,    4							,    19				)
      elif days_to_add == 28 and days_from_phm_to_sunday == 6:
            return datetime(_snake_case							,    4							,    18				)
      else:
            return datetime(_snake_case							,    3							,    22				) + timedelta(
                days=int(days_to_add + days_from_phm_to_sunday				)				)


if __name__ == "__main__":
       for year in (1_994, 2_000, 2_010, 2_021, 2_023):
              a							      =     '''will be''' if year > datetime.now().year else '''was'''
              print(F'''Easter in {year} {tense} {gauss_easter(year)}''')

