import argparse

import torch

from transformers import HubertConfig, HubertForSequenceClassification, WavaVecaFeatureExtractor, logging


logging.set_verbosity_info()
_lowerCamelCase    :      Optional[Any]	 =						logging.get_logger(__name__)

_lowerCamelCase    :      int	 =						['''UtteranceLevel''']





@torch.no_grad()
def 		__lowerCamelCase							(UpperCAmelCase__   :							str					,       UpperCAmelCase__   :							Union[str, Any]					,       UpperCAmelCase__   :							Any					,       UpperCAmelCase__   :							Optional[Any]     ):
					SCREAMING_SNAKE_CASE				=				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}"     )

					SCREAMING_SNAKE_CASE				=				checkpoint["Downstream"]

					SCREAMING_SNAKE_CASE				=				HubertConfig.from_pretrained(UpperCAmelCase__     )
					SCREAMING_SNAKE_CASE				=				HubertForSequenceClassification.from_pretrained(UpperCAmelCase__					,       config=UpperCAmelCase__     )
					SCREAMING_SNAKE_CASE				=				WavaVecaFeatureExtractor.from_pretrained(
					    UpperCAmelCase__					,       return_attention_mask=UpperCAmelCase__					,       do_normalize=UpperCAmelCase__     )

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

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

					hf_feature_extractor.save_pretrained(UpperCAmelCase__     )
					hf_model.save_pretrained(UpperCAmelCase__     )


if __name__ == "__main__":
							_lowerCamelCase    :      int	 =						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.''')
							_lowerCamelCase    :      int	 =						parser.parse_args()
							convert_saprl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)





import math





def 		__lowerCamelCase							(UpperCAmelCase__   :							int     ):

					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 		__lowerCamelCase							(UpperCAmelCase__   :							int = 2_0_0_0_0_0_0     ):
					return sum(num for num in range(3					,       UpperCAmelCase__					,       2     ) if is_prime(UpperCAmelCase__     )     ) + 2 if n > 2 else 0


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




