



"""simple docstring"""
def       _snake_case						(						UpperCamelCase						:		int						):

 if num <= 0:
  raise ValueError("""Input must be a positive integer"""						)

 UpperCAmelCase	:					Any	=	[True] * (num + 1)

 UpperCAmelCase	:					Any	=	2
 while p * p <= num:
  if primes[p]:
   for i in range(p * p			,		num + 1			,		UpperCamelCase						):
    UpperCAmelCase	:					int	=	False
  p += 1

 return [prime for prime in range(2			,		num + 1						) if primes[prime]]


if __name__ == "__main__":
      import doctest

      doctest.testmod()

      A:   int								=		int(input("Enter a positive integer: ").strip())
      print(prime_sieve_eratosthenes(user_num))






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 (
    SwiftFormerConfig,
    SwiftFormerForImageClassification,
    ViTImageProcessor,
)
from transformers.utils import logging


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

_A     =			torch.device('''cpu''')





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





def __UpperCamelCase			(       _A  ):
						if swiftformer_name == "swiftformer_xs":
												return torch.tensor([-2.1_7_0_3E0_0, 2.1_1_0_7E0_0, -2.0_8_1_1E0_0, 8.8_6_8_5E-0_1, 2.4_3_6_0E-0_1]  )

						elif swiftformer_name == "swiftformer_s":
												return torch.tensor([3.9_6_3_6E-0_1, 2.3_4_7_8E-0_1, -1.6_9_6_3E0_0, -1.7_3_8_1E0_0, -8.6_3_3_7E-0_1]  )

						elif swiftformer_name == "swiftformer_l1":
												return torch.tensor([-4.2_7_6_8E-0_1, -4.7_4_2_9E-0_1, -1.0_8_9_7E0_0, -1.0_2_4_8E0_0, 3.5_5_2_3E-0_2]  )

						elif swiftformer_name == "swiftformer_l3":
												return torch.tensor([-2.5_3_3_0E-0_1, 2.4_2_1_1E-0_1, -6.0_1_8_5E-0_1, -8.2_7_8_9E-0_1, -6.0_4_4_6E-0_2]  )





def __UpperCamelCase			(       _A ,  _A ,  _A  ):
						lowerCAmelCase_      			=  dct.pop(_A  )
						lowerCAmelCase_      			=  val





def __UpperCamelCase			(       _A  ):
						lowerCAmelCase_      			=  []
						for k in state_dict.keys():
												lowerCAmelCase_      			=  k
												if ".pwconv" in k:
																		lowerCAmelCase_      			=  k_new.replace('''.pwconv''' ,  '''.point_wise_conv'''  )
												if ".dwconv" in k:
																		lowerCAmelCase_      			=  k_new.replace('''.dwconv''' ,  '''.depth_wise_conv'''  )
												if ".Proj." in k:
																		lowerCAmelCase_      			=  k_new.replace('''.Proj.''' ,  '''.proj.'''  )
												if "patch_embed" in k_new:
																		lowerCAmelCase_      			=  k_new.replace('''patch_embed''' ,  '''swiftformer.patch_embed.patch_embedding'''  )
												if "network" in k_new:
																		lowerCAmelCase_      			=  k_new.split('''.'''  )
																		if ls[2].isdigit():
																								lowerCAmelCase_      			=  '''swiftformer.encoder.network.''' + ls[1] + '''.blocks.''' + ls[2] + '''.''' + '''.'''.join(ls[3:]  )
																		else:
																								lowerCAmelCase_      			=  k_new.replace('''network''' ,  '''swiftformer.encoder.network'''  )
												rename_keys.append((k, k_new)  )
						return rename_keys





@torch.no_grad()
def __UpperCamelCase			(       _A ,  _A ,  _A  ):
						lowerCAmelCase_      			=  SwiftFormerConfig()

						# dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size
						lowerCAmelCase_      			=  1000
						lowerCAmelCase_      			=  '''huggingface/label-files'''
						lowerCAmelCase_      			=  '''imagenet-1k-id2label.json'''
						lowerCAmelCase_      			=  json.load(open(hf_hub_download(_A ,  _A ,  repo_type='''dataset'''  ) ,  '''r'''  )  )
						lowerCAmelCase_      			=  {int(_A  ): v for k, v in idalabel.items()}
						lowerCAmelCase_      			=  idalabel
						lowerCAmelCase_      			=  {v: k for k, v in idalabel.items()}

						# size of the architecture
						if swiftformer_name == "swiftformer_xs":
												lowerCAmelCase_      			=  [3, 3, 6, 4]
												lowerCAmelCase_      			=  [48, 56, 112, 220]

						elif swiftformer_name == "swiftformer_s":
												lowerCAmelCase_      			=  [3, 3, 9, 6]
												lowerCAmelCase_      			=  [48, 64, 168, 224]

						elif swiftformer_name == "swiftformer_l1":
												lowerCAmelCase_      			=  [4, 3, 10, 5]
												lowerCAmelCase_      			=  [48, 96, 192, 384]

						elif swiftformer_name == "swiftformer_l3":
												lowerCAmelCase_      			=  [4, 4, 12, 6]
												lowerCAmelCase_      			=  [64, 128, 320, 512]

						# load state_dict of original model, remove and rename some keys
						if original_ckpt:
												if original_ckpt.startswith('''https'''  ):
																		lowerCAmelCase_      			=  torch.hub.load_state_dict_from_url(_A ,  map_location='''cpu''' ,  check_hash=_A  )
												else:
																		lowerCAmelCase_      			=  torch.load(_A ,  map_location='''cpu'''  )
						lowerCAmelCase_      			=  checkpoint

						lowerCAmelCase_      			=  create_rename_keys(_A  )
						for rename_key_src, rename_key_dest in rename_keys:
												rename_key(_A ,  _A ,  _A  )

						# load HuggingFace model
						lowerCAmelCase_      			=  SwiftFormerForImageClassification(_A  ).eval()
						hf_model.load_state_dict(_A  )

						# prepare test inputs
						lowerCAmelCase_      			=  prepare_img()
						lowerCAmelCase_      			=  ViTImageProcessor.from_pretrained('''preprocessor_config'''  )
						lowerCAmelCase_      			=  processor(images=_A ,  return_tensors='''pt'''  )

						# compare outputs from both models
						lowerCAmelCase_      			=  get_expected_output(_A  )
						lowerCAmelCase_      			=  hf_model(inputs['''pixel_values''']  ).logits

						assert hf_logits.shape == torch.Size([1, 1000]  )
						assert torch.allclose(hf_logits[0, 0:5] ,  _A ,  atol=1E-3  )

						Path(_A  ).mkdir(exist_ok=_A  )
						print(f"Saving model {swiftformer_name} to {pytorch_dump_folder_path}"  )
						hf_model.save_pretrained(_A  )


if __name__ == "__main__":
						_A     =			argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    '''--swiftformer_name''',
						    default='''swiftformer_xs''',
						    choices=['''swiftformer_xs''', '''swiftformer_s''', '''swiftformer_l1''', '''swiftformer_l3'''],
						    type=str,
						    help='''Name of the SwiftFormer model you\'d like to convert.''',
						)
						parser.add_argument(
						    '''--pytorch_dump_folder_path''',
						    default='''./converted_outputs/''',
						    type=str,
						    help='''Path to the output PyTorch model directory.''',
						)
						parser.add_argument('''--original_ckpt''', default=None, type=str, help='''Path to the original model checkpoint.''')

						_A     =			parser.parse_args()
						convert_swiftformer_checkpoint(args.swiftformer_name, args.pytorch_dump_folder_path, args.original_ckpt)




