
"""simple docstring"""






import argparse

import torch

from transformers import HubertConfig, HubertForSequenceClassification, WavaVecaFeatureExtractor, logging


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

UpperCamelCase_						   =   ['UtteranceLevel']
@torch.no_grad()
def    UpperCamelCase						(					UpperCAmelCase ,   UpperCAmelCase ,   UpperCAmelCase ,   UpperCAmelCase     )						->str:

   """simple docstring"""



   a_						   =     torch.load(UpperCAmelCase ,   map_location="cpu"     )
   if checkpoint["Config"]["downstream_expert"]["modelrc"]["select"] not in SUPPORTED_MODELS:
      raise NotImplementedError(F'''The supported s3prl models are {SUPPORTED_MODELS}'''     )

   a_						   =     checkpoint["Downstream"]

   a_						   =     HubertConfig.from_pretrained(UpperCAmelCase     )
   a_						   =     HubertForSequenceClassification.from_pretrained(UpperCAmelCase ,   config=UpperCAmelCase     )
   a_						   =     WavaVecaFeatureExtractor.from_pretrained(
       UpperCAmelCase ,   return_attention_mask=UpperCAmelCase ,   do_normalize=UpperCAmelCase     )

   if hf_congfig.use_weighted_layer_sum:
      a_						   =     checkpoint["Featurizer"]["weights"]

   a_						   =     downstream_dict["projector.weight"]
   a_						   =     downstream_dict["projector.bias"]
   a_						   =     downstream_dict["model.post_net.linear.weight"]
   a_						   =     downstream_dict["model.post_net.linear.bias"]

   hf_feature_extractor.save_pretrained(UpperCAmelCase     )
   hf_model.save_pretrained(UpperCAmelCase     )


if __name__ == "__main__":
      UpperCamelCase_						   =   argparse.ArgumentParser()
      parser.add_argument(
          '--base_model_name', default=None, type=str, help='Name of the huggingface pretrained base model.'
      )
      parser.add_argument('--config_path', default=None, type=str, help='Path to the huggingface classifier config.')
      parser.add_argument('--checkpoint_path', default=None, type=str, help='Path to the s3prl checkpoint.')
      parser.add_argument('--model_dump_path', default=None, type=str, help='Path to the final converted model.')
      UpperCamelCase_						   =   parser.parse_args()
      convert_saprl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)

"""simple docstring"""






import math
def    UpperCamelCase						(					UpperCAmelCase     )						->bool:

   """simple docstring"""



   if 1 < number < 4:
      # 2 and 3 are primes
      return True
   elif number < 2 or number % 2 == 0 or number % 3 == 0:
      # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
      return False

   # All primes number are in format of 6k +/- 1
   for i in range(5 ,   int(math.sqrt(UpperCAmelCase     ) + 1     ) ,   6     ):
      if number % i == 0 or number % (i + 2) == 0:
         return False
   return True
def    UpperCamelCase						(					UpperCAmelCase = 600_851_475_143     )						->int:

   """simple docstring"""



   try:
      a_						   =     int(UpperCAmelCase     )
   except (TypeError, ValueError):
      raise TypeError("Parameter n must be int or castable to int."     )
   if n <= 0:
      raise ValueError("Parameter n must be greater than or equal to one."     )
   a_						   =     0
   if is_prime(UpperCAmelCase     ):
      return n
   while n % 2 == 0:
      n //= 2
   if is_prime(UpperCAmelCase     ):
      return n
   for i in range(3 ,   int(math.sqrt(UpperCAmelCase     )     ) + 1 ,   2     ):
      if n % i == 0:
         if is_prime(n // i     ):
            a_						   =     n // i
            break
         elif is_prime(UpperCAmelCase     ):
            a_						   =     i
   return max_number


if __name__ == "__main__":
      print(F"""{solution() = }""")