





"""simple docstring"""



import argparse

import torch

from transformers import HubertConfig, HubertForSequenceClassification, WavaVecaFeatureExtractor, logging


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

a_				=    ["""UtteranceLevel"""]







@torch.no_grad()
def 	__lowercase  (     snake_case_						:						List[str]       ,snake_case_						:						Optional[int]       ,snake_case_						:						Any       ,snake_case_						:						List[str]		)     ->Union[str, Any]:



    '''simple docstring'''







    __A					:		Union[str, Any]						=  torch.load(snake_case_       ,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					:		str						=  checkpoint['''Downstream''']

    __A					:		List[str]						=  HubertConfig.from_pretrained(snake_case_		)
    __A					:		Dict						=  HubertForSequenceClassification.from_pretrained(snake_case_       ,config=snake_case_		)
    __A					:		Union[str, Any]						=  WavaVecaFeatureExtractor.from_pretrained(
        snake_case_       ,return_attention_mask=snake_case_       ,do_normalize=snake_case_		)

    if hf_congfig.use_weighted_layer_sum:
        __A					:		List[str]						=  checkpoint['''Featurizer''']['''weights''']

    __A					:		Dict						=  downstream_dict['''projector.weight''']
    __A					:		Any						=  downstream_dict['''projector.bias''']
    __A					:		Dict						=  downstream_dict['''model.post_net.linear.weight''']
    __A					:		Union[str, Any]						=  downstream_dict['''model.post_net.linear.bias''']

    hf_feature_extractor.save_pretrained(snake_case_		)
    hf_model.save_pretrained(snake_case_		)


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











"""simple docstring"""



from __future__ import annotations

import sys







def 	__lowercase  (     snake_case_						:						int       ,snake_case_						:						int		)     ->tuple[int, int]:



    '''simple docstring'''







    if abs(snake_case_		) == 1:
        return a, 0
    elif abs(snake_case_		) == 1:
        return 0, b

    __A				, __A					:		int						=  a, b
    __A				, __A					:		Any						=  1, 0
    __A				, __A					:		int						=  0, 1

    while remainder != 0:
        __A					:		List[Any]						=  old_remainder // remainder
        __A				, __A					:		int						=  remainder, old_remainder - quotient * remainder
        __A				, __A					:		List[Any]						=  coeff_a, old_coeff_a - quotient * coeff_a
        __A				, __A					:		Union[str, Any]						=  coeff_b, old_coeff_b - quotient * coeff_b

    # sign correction for negative numbers
    if a < 0:
        __A					:		Optional[Any]						=  -old_coeff_a
    if b < 0:
        __A					:		List[Any]						=  -old_coeff_b

    return old_coeff_a, old_coeff_b







def 	__lowercase  (     )     ->List[str]:



    '''simple docstring'''







    if len(sys.argv		) < 3:
        print('''2 integer arguments required'''		)
        return 1
    __A					:		Optional[int]						=  int(sys.argv[1]		)
    __A					:		Tuple						=  int(sys.argv[2]		)
    print(extended_euclidean_algorithm(snake_case_       ,snake_case_		)		)
    return 0


if __name__ == "__main__":
       raise SystemExit(main())




