






'''simple docstring'''







import argparse
import collections
import json
from pathlib import Path

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

from transformers import (
    MobileViTImageProcessor,
    MobileViTVaConfig,
    MobileViTVaForImageClassification,
    MobileViTVaForSemanticSegmentation,
)
from transformers.utils import logging


logging.set_verbosity_info()
UpperCamelCase    :      Any  			=		logging.get_logger(__name__)
def 						A__			(				__lowerCAmelCase		:			Optional[Any]						):
						print("""Loading config file..."""						)

						def flatten_yaml_as_dict(__lowerCAmelCase		:			Any   ,    __lowerCAmelCase		:			str=""   ,    __lowerCAmelCase		:			Dict="."						):
												lowerCamelCase__         =  []
												for k, v in d.items():
																		lowerCamelCase__         =  parent_key + sep + k if parent_key else k
																		if isinstance(__lowerCAmelCase   ,    collections.abc.MutableMapping						):
																								items.extend(flatten_yaml_as_dict(__lowerCAmelCase   ,    __lowerCAmelCase   ,    sep=__lowerCAmelCase						).items()						)
																		else:
																								items.append((new_key, v)						)
												return dict(__lowerCAmelCase						)

						lowerCamelCase__         =  argparse.Namespace()
						with open(__lowerCAmelCase   ,    """r"""						) as yaml_file:
												try:
																		lowerCamelCase__         =  yaml.load(__lowerCAmelCase   ,    Loader=yaml.FullLoader						)

																		lowerCamelCase__         =  flatten_yaml_as_dict(__lowerCAmelCase						)
																		for k, v in flat_cfg.items():
																								setattr(__lowerCAmelCase   ,    __lowerCAmelCase   ,    __lowerCAmelCase						)
												except yaml.YAMLError as exc:
																		logger.error("""Error while loading config file: {}. Error message: {}""".format(__lowerCAmelCase   ,    str(__lowerCAmelCase						)						)						)
						return config
def 						A__			(				__lowerCAmelCase		:			Optional[Any]   ,    __lowerCAmelCase		:			Union[str, Any]						):
						lowerCamelCase__         =  MobileViTVaConfig()

						lowerCamelCase__         =  False

						# dataset
						if task_name.startswith("""imagenet1k_"""						):
												lowerCamelCase__         =  1000
												if int(task_name.strip().split("""_"""						)[-1]						) == 384:
																		lowerCamelCase__         =  384
												else:
																		lowerCamelCase__         =  256
												lowerCamelCase__         =  """imagenet-1k-id2label.json"""
						elif task_name.startswith("""imagenet21k_to_1k_"""						):
												lowerCamelCase__         =  2_1000
												if int(task_name.strip().split("""_"""						)[-1]						) == 384:
																		lowerCamelCase__         =  384
												else:
																		lowerCamelCase__         =  256
												lowerCamelCase__         =  """imagenet-22k-id2label.json"""
						elif task_name.startswith("""ade20k_"""						):
												lowerCamelCase__         =  151
												lowerCamelCase__         =  512
												lowerCamelCase__         =  """ade20k-id2label.json"""
												lowerCamelCase__         =  True
						elif task_name.startswith("""voc_"""						):
												lowerCamelCase__         =  21
												lowerCamelCase__         =  512
												lowerCamelCase__         =  """pascal-voc-id2label.json"""
												lowerCamelCase__         =  True

						# orig_config
						lowerCamelCase__         =  load_orig_config_file(__lowerCAmelCase						)
						assert getattr(__lowerCAmelCase   ,    """model.classification.name"""   ,    -1						) == "mobilevit_v2", "Invalid model"
						lowerCamelCase__         =  getattr(__lowerCAmelCase   ,    """model.classification.mitv2.width_multiplier"""   ,    1.0						)
						assert (
						    getattr(__lowerCAmelCase   ,    """model.classification.mitv2.attn_norm_layer"""   ,    -1						) == "layer_norm_2d"
						), "Norm layers other than layer_norm_2d is not supported"
						lowerCamelCase__         =  getattr(__lowerCAmelCase   ,    """model.classification.activation.name"""   ,    """swish"""						)
						# config.image_size == getattr(orig_config,  'sampler.bs.crop_size_width', 256)

						if is_segmentation_model:
												lowerCamelCase__         =  getattr(__lowerCAmelCase   ,    """model.segmentation.output_stride"""   ,    16						)
												if "_deeplabv3" in task_name:
																		lowerCamelCase__         =  getattr(__lowerCAmelCase   ,    """model.segmentation.deeplabv3.aspp_rates"""   ,    [12, 24, 36]						)
																		lowerCamelCase__         =  getattr(__lowerCAmelCase   ,    """model.segmentation.deeplabv3.aspp_out_channels"""   ,    512						)
																		lowerCamelCase__         =  getattr(__lowerCAmelCase   ,    """model.segmentation.deeplabv3.aspp_dropout"""   ,    0.1						)

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

						return config
def 						A__			(				__lowerCAmelCase		:			Union[str, Any]   ,    __lowerCAmelCase		:			str   ,    __lowerCAmelCase		:			List[str]						):
						lowerCamelCase__         =  dct.pop(__lowerCAmelCase						)
						lowerCamelCase__         =  val
def 						A__			(				__lowerCAmelCase		:			Dict   ,    __lowerCAmelCase		:			Tuple=False						):
						if base_model:
												lowerCamelCase__         =  """"""
						else:
												lowerCamelCase__         =  """mobilevitv2."""

						lowerCamelCase__         =  []
						for k in state_dict.keys():
												if k[:8] == "encoder.":
																		lowerCamelCase__         =  k[8:]
												else:
																		lowerCamelCase__         =  k

												if ".block." in k:
																		lowerCamelCase__         =  k_new.replace(""".block."""   ,    """."""						)
												if ".conv." in k:
																		lowerCamelCase__         =  k_new.replace(""".conv."""   ,    """.convolution."""						)
												if ".norm." in k:
																		lowerCamelCase__         =  k_new.replace(""".norm."""   ,    """.normalization."""						)

												if "conv_1." in k:
																		lowerCamelCase__         =  k_new.replace("""conv_1."""   ,    F'''{model_prefix}conv_stem.'''						)
												for i in [1, 2]:
																		if F'''layer_{i}.''' in k:
																								lowerCamelCase__         =  k_new.replace(F'''layer_{i}.'''   ,    F'''{model_prefix}encoder.layer.{i-1}.layer.'''						)
												if ".exp_1x1." in k:
																		lowerCamelCase__         =  k_new.replace(""".exp_1x1."""   ,    """.expand_1x1."""						)
												if ".red_1x1." in k:
																		lowerCamelCase__         =  k_new.replace(""".red_1x1."""   ,    """.reduce_1x1."""						)

												for i in [3, 4, 5]:
																		if F'''layer_{i}.0.''' in k:
																								lowerCamelCase__         =  k_new.replace(F'''layer_{i}.0.'''   ,    F'''{model_prefix}encoder.layer.{i-1}.downsampling_layer.'''						)
																		if F'''layer_{i}.1.local_rep.0.''' in k:
																								lowerCamelCase__         =  k_new.replace(F'''layer_{i}.1.local_rep.0.'''   ,    F'''{model_prefix}encoder.layer.{i-1}.conv_kxk.'''						)
																		if F'''layer_{i}.1.local_rep.1.''' in k:
																								lowerCamelCase__         =  k_new.replace(F'''layer_{i}.1.local_rep.1.'''   ,    F'''{model_prefix}encoder.layer.{i-1}.conv_1x1.'''						)

												for i in [3, 4, 5]:
																		if i == 3:
																								lowerCamelCase__         =  [0, 1]
																		elif i == 4:
																								lowerCamelCase__         =  [0, 1, 2, 3]
																		elif i == 5:
																								lowerCamelCase__         =  [0, 1, 2]

																		for j in j_in:
																								if F'''layer_{i}.1.global_rep.{j}.''' in k:
																														lowerCamelCase__         =  k_new.replace(
																														    F'''layer_{i}.1.global_rep.{j}.'''   ,    F'''{model_prefix}encoder.layer.{i-1}.transformer.layer.{j}.'''						)
																		if F'''layer_{i}.1.global_rep.{j+1}.''' in k:
																								lowerCamelCase__         =  k_new.replace(
																								    F'''layer_{i}.1.global_rep.{j+1}.'''   ,    F'''{model_prefix}encoder.layer.{i-1}.layernorm.'''						)

																		if F'''layer_{i}.1.conv_proj.''' in k:
																								lowerCamelCase__         =  k_new.replace(F'''layer_{i}.1.conv_proj.'''   ,    F'''{model_prefix}encoder.layer.{i-1}.conv_projection.'''						)

												if "pre_norm_attn.0." in k:
																		lowerCamelCase__         =  k_new.replace("""pre_norm_attn.0."""   ,    """layernorm_before."""						)
												if "pre_norm_attn.1." in k:
																		lowerCamelCase__         =  k_new.replace("""pre_norm_attn.1."""   ,    """attention."""						)
												if "pre_norm_ffn.0." in k:
																		lowerCamelCase__         =  k_new.replace("""pre_norm_ffn.0."""   ,    """layernorm_after."""						)
												if "pre_norm_ffn.1." in k:
																		lowerCamelCase__         =  k_new.replace("""pre_norm_ffn.1."""   ,    """ffn.conv1."""						)
												if "pre_norm_ffn.3." in k:
																		lowerCamelCase__         =  k_new.replace("""pre_norm_ffn.3."""   ,    """ffn.conv2."""						)

												if "classifier.1." in k:
																		lowerCamelCase__         =  k_new.replace("""classifier.1."""   ,    """classifier."""						)

												if "seg_head." in k:
																		lowerCamelCase__         =  k_new.replace("""seg_head."""   ,    """segmentation_head."""						)
												if ".aspp_layer." in k:
																		lowerCamelCase__         =  k_new.replace(""".aspp_layer."""   ,    """."""						)
												if ".aspp_pool." in k:
																		lowerCamelCase__         =  k_new.replace(""".aspp_pool."""   ,    """."""						)

												rename_keys.append((k, k_new)						)
						return rename_keys
def 						A__			(				__lowerCAmelCase		:			Dict						):
						lowerCamelCase__         =  []
						for k in state_dict.keys():
												if k.startswith("""seg_head.aux_head."""						):
																		keys_to_ignore.append(__lowerCAmelCase						)
						for k in keys_to_ignore:
												state_dict.pop(__lowerCAmelCase   ,    __lowerCAmelCase						)
def 						A__			(				):
						lowerCamelCase__         =  """http://images.cocodataset.org/val2017/000000039769.jpg"""
						# url = "https://cdn.britannica.com/86/141086-050-9D7C75EE/Gulfstream-G450-business-jet-passengers.jpg"
						lowerCamelCase__         =  Image.open(requests.get(__lowerCAmelCase   ,    stream=__lowerCAmelCase						).raw						)
						return im
@torch.no_grad()
def 						A__			(				__lowerCAmelCase		:			List[str]   ,    __lowerCAmelCase		:			Optional[int]   ,    __lowerCAmelCase		:			Dict   ,    __lowerCAmelCase		:			str						):
						lowerCamelCase__         =  get_mobilevitva_config(__lowerCAmelCase   ,    __lowerCAmelCase						)

						# load original state_dict
						lowerCamelCase__         =  torch.load(__lowerCAmelCase   ,    map_location="""cpu"""						)

						# load huggingface model
						if task_name.startswith("""ade20k_"""						) or task_name.startswith("""voc_"""						):
												lowerCamelCase__         =  MobileViTVaForSemanticSegmentation(__lowerCAmelCase						).eval()
												lowerCamelCase__         =  False
						else:
												lowerCamelCase__         =  MobileViTVaForImageClassification(__lowerCAmelCase						).eval()
												lowerCamelCase__         =  False

						# remove and rename some keys of load the original model
						lowerCamelCase__         =  checkpoint
						remove_unused_keys(__lowerCAmelCase						)
						lowerCamelCase__         =  create_rename_keys(__lowerCAmelCase   ,    base_model=__lowerCAmelCase						)
						for rename_key_src, rename_key_dest in rename_keys:
												rename_key(__lowerCAmelCase   ,    __lowerCAmelCase   ,    __lowerCAmelCase						)

						# load modified state_dict
						model.load_state_dict(__lowerCAmelCase						)

						# Check outputs on an image, prepared by MobileViTImageProcessor
						lowerCamelCase__         =  MobileViTImageProcessor(crop_size=config.image_size   ,    size=config.image_size + 32						)
						lowerCamelCase__         =  image_processor(images=prepare_img()   ,    return_tensors="""pt"""						)
						lowerCamelCase__         =  model(**__lowerCAmelCase						)

						# verify classification model
						if task_name.startswith("""imagenet"""						):
												lowerCamelCase__         =  outputs.logits
												lowerCamelCase__         =  logits.argmax(-1						).item()
												print("""Predicted class:"""   ,    model.config.idalabel[predicted_class_idx]						)
												if task_name.startswith("""imagenet1k_256"""						) and config.width_multiplier == 1.0:
																		# expected_logits for base variant
																		lowerCamelCase__         =  torch.tensor([-1.6_336e00, -7.3_204e-02, -5.1_883e-01]						)
																		assert torch.allclose(logits[0, :3]   ,    __lowerCAmelCase   ,    atol=1e-4						)

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


if __name__ == "__main__":
							UpperCamelCase    :      Tuple  			=		argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    '--task',
							    default='imagenet1k_256',
							    type=str,
							    help=(
							        'Name of the task for which the MobileViTV2 model you\'d like to convert is trained on . '
							        '\n                Classification (ImageNet-1k)\n                    - MobileViTV2 (256x256) : imagenet1k_256\n                    - MobileViTV2 (Trained on 256x256 and Finetuned on 384x384) : imagenet1k_384\n                    - MobileViTV2 (Trained on ImageNet-21k and Finetuned on ImageNet-1k 256x256) :\n                      imagenet21k_to_1k_256\n                    - MobileViTV2 (Trained on ImageNet-21k, Finetuned on ImageNet-1k 256x256, and Finetuned on\n                      ImageNet-1k 384x384) : imagenet21k_to_1k_384\n                Segmentation\n                    - ADE20K Dataset : ade20k_deeplabv3\n                    - Pascal VOC 2012 Dataset: voc_deeplabv3\n            '
							    ),
							    choices=[
							        'imagenet1k_256',
							        'imagenet1k_384',
							        'imagenet21k_to_1k_256',
							        'imagenet21k_to_1k_384',
							        'ade20k_deeplabv3',
							        'voc_deeplabv3',
							    ],
							)

							parser.add_argument(
							    '--orig_checkpoint_path', required=True, type=str, help='Path to the original state dict (.pt file).'
							)
							parser.add_argument('--orig_config_path', required=True, type=str, help='Path to the original config file.')
							parser.add_argument(
							    '--pytorch_dump_folder_path', required=True, type=str, help='Path to the output PyTorch model directory.'
							)

							UpperCamelCase    :      Dict  			=		parser.parse_args()
							convert_mobilevitva_checkpoint(
							    args.task, args.orig_checkpoint_path, args.orig_config_path, args.pytorch_dump_folder_path
							)









'''simple docstring'''







from math import factorial

UpperCamelCase    :      dict[str, int]  			=		{str(digit): factorial(digit) for digit in range(10)}
def 						A__			(				__lowerCAmelCase		:			int						):
						if not isinstance(__lowerCAmelCase   ,    __lowerCAmelCase						):
												raise TypeError("""Parameter number must be int"""						)

						if number < 0:
												raise ValueError("""Parameter number must be greater than or equal to 0"""						)

						# Converts number in string to iterate on its digits and adds its factorial.
						return sum(DIGIT_FACTORIAL[digit] for digit in str(__lowerCAmelCase						)						)
def 						A__			(				__lowerCAmelCase		:			int = 60   ,    __lowerCAmelCase		:			int = 100_0000						):

						if not isinstance(__lowerCAmelCase   ,    __lowerCAmelCase						) or not isinstance(__lowerCAmelCase   ,    __lowerCAmelCase						):
												raise TypeError("""Parameters chain_length and number_limit must be int"""						)

						if chain_length <= 0 or number_limit <= 0:
												raise ValueError(
												    """Parameters chain_length and number_limit must be greater than 0"""						)

						# the counter for the chains with the exact desired length
						lowerCamelCase__         =  0
						# the cached sizes of the previous chains
						lowerCamelCase__         =  {}

						for start_chain_element in range(1   ,    __lowerCAmelCase						):
												# The temporary set will contain the elements of the chain
												lowerCamelCase__         =  set()
												lowerCamelCase__         =  0

												# Stop computing the chain when you find a cached size, a repeating item or the
												# length is greater then the desired one.
												lowerCamelCase__         =  start_chain_element
												while (
												    chain_element not in chain_sets_lengths
												    and chain_element not in chain_set
												    and chain_set_length <= chain_length
												):
																		chain_set.add(__lowerCAmelCase						)
																		chain_set_length += 1
																		lowerCamelCase__         =  digit_factorial_sum(__lowerCAmelCase						)

												if chain_element in chain_sets_lengths:
																		chain_set_length += chain_sets_lengths[chain_element]

												lowerCamelCase__         =  chain_set_length

												# If chain contains the exact amount of elements increase the counter
												if chain_set_length == chain_length:
																		chains_counter += 1

						return chains_counter


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							print(F'{solution()}')

