






'''simple docstring'''



import argparse

import torch

from transformers import BertForMaskedLM


if __name__ == "__main__":
 __UpperCamelCase      :       str      			=      argparse.ArgumentParser(
     description=(
         """Extraction some layers of the full BertForMaskedLM or RObertaForMaskedLM for Transfer Learned"""
         """ Distillation"""
     )
 )
 parser.add_argument("""--model_type""", default="""bert""", choices=["""bert"""])
 parser.add_argument("""--model_name""", default="""bert-base-uncased""", type=str)
 parser.add_argument("""--dump_checkpoint""", default="""serialization_dir/tf_bert-base-uncased_0247911.pth""", type=str)
 parser.add_argument("""--vocab_transform""", action="""store_true""")
 __UpperCamelCase      :       Tuple      			=      parser.parse_args()

 if args.model_type == "bert":
  __UpperCamelCase      :       Optional[int]      			=      BertForMaskedLM.from_pretrained(args.model_name)
  __UpperCamelCase      :       Tuple      			=      """bert"""
 else:
  raise ValueError("""args.model_type should be \"bert\".""")

 __UpperCamelCase      :       Dict      			=      model.state_dict()
 __UpperCamelCase      :       int      			=      {}

 for w in ["word_embeddings", "position_embeddings"]:
  __UpperCamelCase      :       Dict      			=      state_dict[f"""{prefix}.embeddings.{w}.weight"""]
 for w in ["weight", "bias"]:
  __UpperCamelCase      :       Optional[int]      			=      state_dict[f"""{prefix}.embeddings.LayerNorm.{w}"""]

 __UpperCamelCase      :       str      			=      0
 for teacher_idx in [0, 2, 4, 7, 9, 11]:
  for w in ["weight", "bias"]:
   __UpperCamelCase      :       List[str]      			=      state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.attention.self.query.{w}"""
   ]
   __UpperCamelCase      :       Any      			=      state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.attention.self.key.{w}"""
   ]
   __UpperCamelCase      :       List[Any]      			=      state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.attention.self.value.{w}"""
   ]

   __UpperCamelCase      :       int      			=      state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.attention.output.dense.{w}"""
   ]
   __UpperCamelCase      :       Dict      			=      state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.attention.output.LayerNorm.{w}"""
   ]

   __UpperCamelCase      :       Optional[Any]      			=      state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.intermediate.dense.{w}"""
   ]
   __UpperCamelCase      :       Optional[Any]      			=      state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.output.dense.{w}"""
   ]
   __UpperCamelCase      :       List[str]      			=      state_dict[
       f"""{prefix}.encoder.layer.{teacher_idx}.output.LayerNorm.{w}"""
   ]
  std_idx += 1

 __UpperCamelCase      :       Tuple      			=      state_dict["""cls.predictions.decoder.weight"""]
 __UpperCamelCase      :       List[str]      			=      state_dict["""cls.predictions.bias"""]
 if args.vocab_transform:
  for w in ["weight", "bias"]:
   __UpperCamelCase      :       Optional[Any]      			=      state_dict[f"""cls.predictions.transform.dense.{w}"""]
   __UpperCamelCase      :       List[Any]      			=      state_dict[f"""cls.predictions.transform.LayerNorm.{w}"""]

 print(f"""N layers selected for distillation: {std_idx}""")
 print(f"""Number of params transferred for distillation: {len(compressed_sd.keys())}""")

 print(f"""Save transferred checkpoint to {args.dump_checkpoint}.""")
 torch.save(compressed_sd, args.dump_checkpoint)







'''simple docstring'''



from maths.prime_factors import prime_factors



def    __UpperCAmelCase	(				SCREAMING_SNAKE_CASE__:	int    )  ->			int:

   """simple docstring"""
   if not isinstance(SCREAMING_SNAKE_CASE__,					SCREAMING_SNAKE_CASE__    ):
      __a				     =    f"""Input value of [number={number}] must be an integer"""
      raise TypeError(SCREAMING_SNAKE_CASE__    )
   if number < 1:
      raise ValueError('Input must be a positive integer'    )
   return -1 if len(prime_factors(SCREAMING_SNAKE_CASE__    )    ) % 2 else 1


if __name__ == "__main__":
 import doctest

 doctest.testmod()