



def __lowerCAmelCase	(       ):
			lowercase__   					=			[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

			lowercase__   					=			6
			lowercase__   					=			1
			lowercase__   					=			1901

			lowercase__   					=			0

			while year < 2001:
						day += 7

						if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
									if day > days_per_month[month - 1] and month != 2:
												month += 1
												lowercase__   					=			day - days_per_month[month - 2]
									elif day > 29 and month == 2:
												month += 1
												lowercase__   					=			day - 29
						else:
									if day > days_per_month[month - 1]:
												month += 1
												lowercase__   					=			day - days_per_month[month - 2]

						if month > 12:
									year += 1
									lowercase__   					=			1

						if year < 2001 and day == 1:
									sundays += 1
			return sundays


if __name__ == "__main__":
							print(solution())









import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from timm import create_model
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import BitConfig, BitForImageClassification, BitImageProcessor
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


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



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			lowercase__   					=			"huggingface/label-files"
			lowercase__   					=			"imagenet-1k-id2label.json"
			lowercase__   					=			json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_  ,					repo_type="dataset"					)  ,					"r"					)					)
			lowercase__   					=			{int(SCREAMING_SNAKE_CASE_					): v for k, v in idalabel.items()}
			lowercase__   					=			{v: k for k, v in idalabel.items()}

			lowercase__   					=			"std_conv" if "bit" in model_name else False

			# note that when using BiT as backbone for ViT-hybrid checkpoints,
			# one needs to additionally set config.layer_type = "bottleneck", config.stem_type = "same",
			# config.conv_layer = "std_conv_same"
			lowercase__   					=			BitConfig(
			    conv_layer=SCREAMING_SNAKE_CASE_  ,					num_labels=1000  ,					idalabel=SCREAMING_SNAKE_CASE_  ,					labelaid=SCREAMING_SNAKE_CASE_  ,					)

			return config



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			if "stem.conv" in name:
						lowercase__   					=			name.replace("stem.conv"  ,					"bit.embedder.convolution"					)
			if "blocks" in name:
						lowercase__   					=			name.replace("blocks"  ,					"layers"					)
			if "head.fc" in name:
						lowercase__   					=			name.replace("head.fc"  ,					"classifier.1"					)
			if name.startswith("norm"					):
						lowercase__   					=			"bit." + name
			if "bit" not in name and "classifier" not in name:
						lowercase__   					=			"bit.encoder." + name

			return name



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



@torch.no_grad()
def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_=False					):
			lowercase__   					=			get_config(SCREAMING_SNAKE_CASE_					)

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

			# load state_dict of original model
			lowercase__   					=			timm_model.state_dict()
			for key in state_dict.copy().keys():
						lowercase__   					=			state_dict.pop(SCREAMING_SNAKE_CASE_					)
						lowercase__   					=			val.squeeze() if "head" in key else val

			# load HuggingFace model
			lowercase__   					=			BitForImageClassification(SCREAMING_SNAKE_CASE_					)
			model.eval()
			model.load_state_dict(SCREAMING_SNAKE_CASE_					)

			# create image processor
			lowercase__   					=			create_transform(**resolve_data_config({}  ,					model=SCREAMING_SNAKE_CASE_					)					)
			lowercase__   					=			transform.transforms

			lowercase__   					=			{
			    "bilinear": PILImageResampling.BILINEAR,
			    "bicubic": PILImageResampling.BICUBIC,
			    "nearest": PILImageResampling.NEAREST,
			}

			lowercase__   					=			BitImageProcessor(
			    do_resize=SCREAMING_SNAKE_CASE_  ,					size={"shortest_edge": timm_transforms[0].size}  ,					resample=pillow_resamplings[timm_transforms[0].interpolation.value]  ,					do_center_crop=SCREAMING_SNAKE_CASE_  ,					crop_size={"height": timm_transforms[1].size[0], "width": timm_transforms[1].size[1]}  ,					do_normalize=SCREAMING_SNAKE_CASE_  ,					image_mean=timm_transforms[-1].mean.tolist()  ,					image_std=timm_transforms[-1].std.tolist()  ,					)

			lowercase__   					=			prepare_img()
			lowercase__   					=			transform(SCREAMING_SNAKE_CASE_					).unsqueeze(0					)
			lowercase__   					=			processor(SCREAMING_SNAKE_CASE_  ,					return_tensors="pt"					).pixel_values

			# verify pixel values
			assert torch.allclose(SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_					)

			# verify logits
			with torch.no_grad():
						lowercase__   					=			model(SCREAMING_SNAKE_CASE_					)
						lowercase__   					=			outputs.logits

			print("Logits:"  ,					logits[0, :3]					)
			print("Predicted class:"  ,					model.config.idalabel[logits.argmax(-1					).item()]					)
			lowercase__   					=			timm_model(SCREAMING_SNAKE_CASE_					)
			assert timm_logits.shape == outputs.logits.shape
			assert torch.allclose(SCREAMING_SNAKE_CASE_  ,					outputs.logits  ,					atol=1e-3					)
			print("Looks ok!"					)

			if pytorch_dump_folder_path is not None:
						Path(SCREAMING_SNAKE_CASE_					).mkdir(exist_ok=SCREAMING_SNAKE_CASE_					)
						print(f'''Saving model {model_name} and processor to {pytorch_dump_folder_path}'''					)
						model.save_pretrained(SCREAMING_SNAKE_CASE_					)
						processor.save_pretrained(SCREAMING_SNAKE_CASE_					)

			if push_to_hub:
						print(f'''Pushing model {model_name} and processor to the hub'''					)
						model.push_to_hub(f'''ybelkada/{model_name}'''					)
						processor.push_to_hub(f'''ybelkada/{model_name}'''					)


if __name__ == "__main__":
							lowercase_						=       argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    """--model_name""",
							    default="""resnetv2_50x1_bitm""",
							    type=str,
							    help="""Name of the BiT 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."""
							)
							parser.add_argument(
							    """--push_to_hub""",
							    action="""store_true""",
							    help="""Whether to push the model to the hub.""",
							)

							lowercase_						=       parser.parse_args()
							convert_bit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




