






"""simple docstring"""







import random





class   UpperCamelCase_ :



  @staticmethod
  def 		UpperCamelCase_				(      snake_case__				)			->			tuple[list[int], list[int]]:



         """simple docstring"""





         UpperCAmelCase	    =			[ord(snake_case__				) for i in text]
         UpperCAmelCase	    =			[]
         UpperCAmelCase	    =			[]
         for i in plain:
                UpperCAmelCase	    =			random.randint(1 ,		3_00				)
                UpperCAmelCase	    =			(i + k) * k
                cipher.append(snake_case__				)
                key.append(snake_case__				)
         return cipher, key



  @staticmethod
  def 		UpperCamelCase_				(      snake_case__ ,		snake_case__				)			->			str:



         """simple docstring"""





         UpperCAmelCase	    =			[]
         for i in range(len(snake_case__				)				):
                UpperCAmelCase	    =			int((cipher[i] - (key[i]) ** 2) / key[i]				)
                plain.append(chr(snake_case__				)				)
         return "".join(snake_case__				)


if __name__ == "__main__":
 lowerCAmelCase_     ,					lowerCAmelCase_	:    int            =      Onepad().encrypt('''Hello''')
 print(c, k)
 print(Onepad().decrypt(c, k))








"""simple docstring"""







import argparse
import json
import os

import numpy as np
import PIL
import requests
import tensorflow.keras.applications.efficientnet as efficientnet
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from tensorflow.keras.preprocessing import image

from transformers import (
    EfficientNetConfig,
    EfficientNetForImageClassification,
    EfficientNetImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
lowerCAmelCase_	:    List[Any]            =      logging.get_logger(__name__)

lowerCAmelCase_	:    Tuple            =      {
    '''b0''': efficientnet.EfficientNetBa,
    '''b1''': efficientnet.EfficientNetBa,
    '''b2''': efficientnet.EfficientNetBa,
    '''b3''': efficientnet.EfficientNetBa,
    '''b4''': efficientnet.EfficientNetBa,
    '''b5''': efficientnet.EfficientNetBa,
    '''b6''': efficientnet.EfficientNetBa,
    '''b7''': efficientnet.EfficientNetBa,
}

lowerCAmelCase_	:    int            =      {
    '''b0''': {
        '''hidden_dim''': 1_2_8_0,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.0,
        '''image_size''': 2_2_4,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [],
    },
    '''b1''': {
        '''hidden_dim''': 1_2_8_0,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.1,
        '''image_size''': 2_4_0,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [1_6],
    },
    '''b2''': {
        '''hidden_dim''': 1_4_0_8,
        '''width_coef''': 1.1,
        '''depth_coef''': 1.2,
        '''image_size''': 2_6_0,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 8, 1_6],
    },
    '''b3''': {
        '''hidden_dim''': 1_5_3_6,
        '''width_coef''': 1.2,
        '''depth_coef''': 1.4,
        '''image_size''': 3_0_0,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 1_8],
    },
    '''b4''': {
        '''hidden_dim''': 1_7_9_2,
        '''width_coef''': 1.4,
        '''depth_coef''': 1.8,
        '''image_size''': 3_8_0,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [6],
    },
    '''b5''': {
        '''hidden_dim''': 2_0_4_8,
        '''width_coef''': 1.6,
        '''depth_coef''': 2.2,
        '''image_size''': 4_5_6,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [1_3, 2_7],
    },
    '''b6''': {
        '''hidden_dim''': 2_3_0_4,
        '''width_coef''': 1.8,
        '''depth_coef''': 2.6,
        '''image_size''': 5_2_8,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [3_1],
    },
    '''b7''': {
        '''hidden_dim''': 2_5_6_0,
        '''width_coef''': 2.0,
        '''depth_coef''': 3.1,
        '''image_size''': 6_0_0,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [1_8],
    },
}






def       _lowerCAmelCase       (      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			EfficientNetConfig()
       UpperCAmelCase	    =			CONFIG_MAP[model_name]["""hidden_dim"""]
       UpperCAmelCase	    =			CONFIG_MAP[model_name]["""width_coef"""]
       UpperCAmelCase	    =			CONFIG_MAP[model_name]["""depth_coef"""]
       UpperCAmelCase	    =			CONFIG_MAP[model_name]["""image_size"""]
       UpperCAmelCase	    =			CONFIG_MAP[model_name]["""dropout_rate"""]
       UpperCAmelCase	    =			CONFIG_MAP[model_name]["""dw_padding"""]

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

       UpperCAmelCase	    =			idalabel
       UpperCAmelCase	    =			{v: k for k, v in idalabel.items()}
       return config






def       _lowerCAmelCase       (      ):







       '''simple docstring'''
       UpperCAmelCase	    =			"""http://images.cocodataset.org/val2017/000000039769.jpg"""
       UpperCAmelCase	    =			Image.open(requests.get(lowerCAmelCase	,      stream=lowerCAmelCase		).raw		)
       return im






def       _lowerCAmelCase       (      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			CONFIG_MAP[model_name]["""image_size"""]
       UpperCAmelCase	    =			EfficientNetImageProcessor(
           size={"""height""": size, """width""": size}	,      image_mean=[0.4_85, 0.4_56, 0.4_06]	,      image_std=[0.47_85_39_44, 0.4_73_28_64, 0.47_43_41_63]	,      do_center_crop=lowerCAmelCase	,      )
       return preprocessor






def       _lowerCAmelCase       (      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			[v.split("""_"""		)[0].split("""block"""		)[1] for v in original_param_names if v.startswith("""block"""		)]
       UpperCAmelCase	    =			sorted(set(lowerCAmelCase		)		)
       UpperCAmelCase	    =			len(lowerCAmelCase		)
       UpperCAmelCase	    =			{b: str(lowerCAmelCase		) for b, i in zip(lowerCAmelCase	,      range(lowerCAmelCase		)		)}

       UpperCAmelCase	    =			[]
       rename_keys.append(("""stem_conv/kernel:0""", """embeddings.convolution.weight""")		)
       rename_keys.append(("""stem_bn/gamma:0""", """embeddings.batchnorm.weight""")		)
       rename_keys.append(("""stem_bn/beta:0""", """embeddings.batchnorm.bias""")		)
       rename_keys.append(("""stem_bn/moving_mean:0""", """embeddings.batchnorm.running_mean""")		)
       rename_keys.append(("""stem_bn/moving_variance:0""", """embeddings.batchnorm.running_var""")		)

       for b in block_names:
              UpperCAmelCase	    =			block_name_mapping[b]
              rename_keys.append((F'''block{b}_expand_conv/kernel:0''', F'''encoder.blocks.{hf_b}.expansion.expand_conv.weight''')		)
              rename_keys.append((F'''block{b}_expand_bn/gamma:0''', F'''encoder.blocks.{hf_b}.expansion.expand_bn.weight''')		)
              rename_keys.append((F'''block{b}_expand_bn/beta:0''', F'''encoder.blocks.{hf_b}.expansion.expand_bn.bias''')		)
              rename_keys.append(
                  (F'''block{b}_expand_bn/moving_mean:0''', F'''encoder.blocks.{hf_b}.expansion.expand_bn.running_mean''')		)
              rename_keys.append(
                  (F'''block{b}_expand_bn/moving_variance:0''', F'''encoder.blocks.{hf_b}.expansion.expand_bn.running_var''')		)
              rename_keys.append(
                  (F'''block{b}_dwconv/depthwise_kernel:0''', F'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight''')		)
              rename_keys.append((F'''block{b}_bn/gamma:0''', F'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight''')		)
              rename_keys.append((F'''block{b}_bn/beta:0''', F'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias''')		)
              rename_keys.append(
                  (F'''block{b}_bn/moving_mean:0''', F'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean''')		)
              rename_keys.append(
                  (F'''block{b}_bn/moving_variance:0''', F'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var''')		)

              rename_keys.append((F'''block{b}_se_reduce/kernel:0''', F'''encoder.blocks.{hf_b}.squeeze_excite.reduce.weight''')		)
              rename_keys.append((F'''block{b}_se_reduce/bias:0''', F'''encoder.blocks.{hf_b}.squeeze_excite.reduce.bias''')		)
              rename_keys.append((F'''block{b}_se_expand/kernel:0''', F'''encoder.blocks.{hf_b}.squeeze_excite.expand.weight''')		)
              rename_keys.append((F'''block{b}_se_expand/bias:0''', F'''encoder.blocks.{hf_b}.squeeze_excite.expand.bias''')		)
              rename_keys.append(
                  (F'''block{b}_project_conv/kernel:0''', F'''encoder.blocks.{hf_b}.projection.project_conv.weight''')		)
              rename_keys.append((F'''block{b}_project_bn/gamma:0''', F'''encoder.blocks.{hf_b}.projection.project_bn.weight''')		)
              rename_keys.append((F'''block{b}_project_bn/beta:0''', F'''encoder.blocks.{hf_b}.projection.project_bn.bias''')		)
              rename_keys.append(
                  (F'''block{b}_project_bn/moving_mean:0''', F'''encoder.blocks.{hf_b}.projection.project_bn.running_mean''')		)
              rename_keys.append(
                  (F'''block{b}_project_bn/moving_variance:0''', F'''encoder.blocks.{hf_b}.projection.project_bn.running_var''')		)

       rename_keys.append(("""top_conv/kernel:0""", """encoder.top_conv.weight""")		)
       rename_keys.append(("""top_bn/gamma:0""", """encoder.top_bn.weight""")		)
       rename_keys.append(("""top_bn/beta:0""", """encoder.top_bn.bias""")		)
       rename_keys.append(("""top_bn/moving_mean:0""", """encoder.top_bn.running_mean""")		)
       rename_keys.append(("""top_bn/moving_variance:0""", """encoder.top_bn.running_var""")		)

       UpperCAmelCase	    =			{}
       for item in rename_keys:
              if item[0] in original_param_names:
                     UpperCAmelCase	    =			"""efficientnet.""" + item[1]

       UpperCAmelCase	    =			"""classifier.weight"""
       UpperCAmelCase	    =			"""classifier.bias"""
       return key_mapping






def       _lowerCAmelCase       (      lowerCAmelCase	,      lowerCAmelCase	,      lowerCAmelCase		):







       '''simple docstring'''
       for key, value in tf_params.items():
              if "normalization" in key:
                     continue

              UpperCAmelCase	    =			key_mapping[key]
              if "_conv" in key and "kernel" in key:
                     UpperCAmelCase	    =			torch.from_numpy(lowerCAmelCase		).permute(3	,      2	,      0	,      1		)
              elif "depthwise_kernel" in key:
                     UpperCAmelCase	    =			torch.from_numpy(lowerCAmelCase		).permute(2	,      3	,      0	,      1		)
              elif "kernel" in key:
                     UpperCAmelCase	    =			torch.from_numpy(np.transpose(lowerCAmelCase		)		)
              else:
                     UpperCAmelCase	    =			torch.from_numpy(lowerCAmelCase		)

              # Replace HF parameters with original TF model parameters
              assert hf_params[hf_key].shape == new_hf_value.shape
              hf_params[hf_key].copy_(lowerCAmelCase		)






@torch.no_grad()
def       _lowerCAmelCase       (      lowerCAmelCase	,      lowerCAmelCase	,      lowerCAmelCase	,      lowerCAmelCase		):







       '''simple docstring'''
       UpperCAmelCase	    =			model_classes[model_name](
           include_top=lowerCAmelCase	,      weights="""imagenet"""	,      input_tensor=lowerCAmelCase	,      input_shape=lowerCAmelCase	,      pooling=lowerCAmelCase	,      classes=1000	,      classifier_activation="""softmax"""	,      )

       UpperCAmelCase	    =			original_model.trainable_variables
       UpperCAmelCase	    =			original_model.non_trainable_variables
       UpperCAmelCase	    =			{param.name: param.numpy() for param in tf_params}
       for param in tf_non_train_params:
              UpperCAmelCase	    =			param.numpy()
       UpperCAmelCase	    =			list(tf_params.keys()		)

       # Load HuggingFace model
       UpperCAmelCase	    =			get_efficientnet_config(lowerCAmelCase		)
       UpperCAmelCase	    =			EfficientNetForImageClassification(lowerCAmelCase		).eval()
       UpperCAmelCase	    =			hf_model.state_dict()

       # Create src-to-dst parameter name mapping dictionary
       print("""Converting parameters..."""		)
       UpperCAmelCase	    =			rename_keys(lowerCAmelCase		)
       replace_params(lowerCAmelCase	,      lowerCAmelCase	,      lowerCAmelCase		)

       # Initialize preprocessor and preprocess input image
       UpperCAmelCase	    =			convert_image_processor(lowerCAmelCase		)
       UpperCAmelCase	    =			preprocessor(images=prepare_img()	,      return_tensors="""pt"""		)

       # HF model inference
       hf_model.eval()
       with torch.no_grad():
              UpperCAmelCase	    =			hf_model(**lowerCAmelCase		)
       UpperCAmelCase	    =			outputs.logits.detach().numpy()

       # Original model inference
       UpperCAmelCase	    =			False
       UpperCAmelCase	    =			CONFIG_MAP[model_name]["""image_size"""]
       UpperCAmelCase	    =			prepare_img().resize((image_size, image_size)	,      resample=PIL.Image.NEAREST		)
       UpperCAmelCase	    =			image.img_to_array(lowerCAmelCase		)
       UpperCAmelCase	    =			np.expand_dims(lowerCAmelCase	,      axis=0		)
       UpperCAmelCase	    =			original_model.predict(lowerCAmelCase		)

       # Check whether original and HF model outputs match  -> np.allclose
       assert np.allclose(lowerCAmelCase	,      lowerCAmelCase	,      atol=1e-3		), "The predicted logits are not the same."
       print("""Model outputs match!"""		)

       if save_model:
              # Create folder to save model
              if not os.path.isdir(lowerCAmelCase		):
                     os.mkdir(lowerCAmelCase		)
              # Save converted model and image processor
              hf_model.save_pretrained(lowerCAmelCase		)
              preprocessor.save_pretrained(lowerCAmelCase		)

       if push_to_hub:
              # Push model and image processor to hub
              print(F'''Pushing converted {model_name} to the hub...'''		)
              UpperCAmelCase	    =			F'''efficientnet-{model_name}'''
              preprocessor.push_to_hub(lowerCAmelCase		)
              hf_model.push_to_hub(lowerCAmelCase		)


if __name__ == "__main__":
 lowerCAmelCase_	:    int            =      argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '''--model_name''',
     default='''b0''',
     type=str,
     help='''Version name of the EfficientNet model you want to convert, select from [b0, b1, b2, b3, b4, b5, b6, b7].''',
 )
 parser.add_argument(
     '''--pytorch_dump_folder_path''',
     default='''hf_model''',
     type=str,
     help='''Path to the output PyTorch model directory.''',
 )
 parser.add_argument('''--save_model''', action='''store_true''', help='''Save model to local''')
 parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Push model and image processor to the hub''')

 lowerCAmelCase_	:    Optional[Any]            =      parser.parse_args()
 convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)
