code: 
  
  
  
  
  
  
  import argparse
  
  import torch
  
  from transformers import HubertConfig, HubertForSequenceClassification, WavaVecaFeatureExtractor, logging
  
  
  logging.set_verbosity_info()
  lowerCamelCase			:							Union[str, Any]       =logging.get_logger(__name__)
  
  lowerCamelCase			:							List[str]       =['''UtteranceLevel''']
  
  
  
  
  
  
  
  @torch.no_grad()
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )				->			Union[str, Any]:
       UpperCamelCase__    :     List[Any]        =						torch.load(__lowerCAmelCase      ,					map_location="cpu"    )
       if checkpoint["Config"]["downstream_expert"]["modelrc"]["select"] not in SUPPORTED_MODELS:
            raise NotImplementedError(f'The supported s3prl models are {SUPPORTED_MODELS}'    )
  
       UpperCamelCase__    :     Tuple        =						checkpoint["Downstream"]
  
       UpperCamelCase__    :     Dict        =						HubertConfig.from_pretrained(__lowerCAmelCase    )
       UpperCamelCase__    :     Union[str, Any]        =						HubertForSequenceClassification.from_pretrained(__lowerCAmelCase      ,					config=__lowerCAmelCase    )
       UpperCamelCase__    :     List[Any]        =						WavaVecaFeatureExtractor.from_pretrained(
           __lowerCAmelCase      ,					return_attention_mask=__lowerCAmelCase      ,					do_normalize=__lowerCAmelCase    )
  
       if hf_congfig.use_weighted_layer_sum:
            UpperCamelCase__    :     List[Any]        =						checkpoint["Featurizer"]["weights"]
  
       UpperCamelCase__    :     Optional[int]        =						downstream_dict["projector.weight"]
       UpperCamelCase__    :     Union[str, Any]        =						downstream_dict["projector.bias"]
       UpperCamelCase__    :     List[Any]        =						downstream_dict["model.post_net.linear.weight"]
       UpperCamelCase__    :     Optional[Any]        =						downstream_dict["model.post_net.linear.bias"]
  
       hf_feature_extractor.save_pretrained(__lowerCAmelCase    )
       hf_model.save_pretrained(__lowerCAmelCase    )
  
  
  if __name__ == "__main__":
   lowerCamelCase			:							str       =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			:							Any       =parser.parse_args()
   convert_saprl_checkpoint(args.base_model_name, args.config_path, args.checkpoint_path, args.model_dump_path)
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  
  from collections.abc import Iterator
  from typing import Any
  
  
  
  
  
  class     __a						:
  
  
  
  
  
  
  
   def __init__(	self      :     str							,     SCREAMING_SNAKE_CASE      :     Any		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        UpperCamelCase__    :     Any        =						data
        UpperCamelCase__    :     Node | None        =						None
  
  
  
  
  
  
  
   def __str__(	self      :     Union[str, Any]		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        return F'{self.data}'
  
  
  
  
  
  
  
  class     __a						:
  
  
  
  
  
  
  
   def __init__(	self      :     Optional[int]		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        UpperCamelCase__    :     Node | None        =						None
        UpperCamelCase__    :     Node | None        =						None
  
  
  
  
  
  
  
   def __iter__(	self      :     str		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        UpperCamelCase__    :     int        =						self.front
        while node:
             yield node.data
             UpperCamelCase__    :     Any        =						node.next
  
  
  
  
  
  
  
   def __len__(	self      :     Tuple		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        return len(tuple(iter(self		)		)		)
  
  
  
  
  
  
  
   def __str__(	self      :     Union[str, Any]		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        return " <- ".join(str(SCREAMING_SNAKE_CASE		) for item in self		)
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     List[str]		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        return len(self		) == 0
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     Union[str, Any]							,     SCREAMING_SNAKE_CASE      :     Any		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        UpperCamelCase__    :     int        =						Node(SCREAMING_SNAKE_CASE		)
        if self.is_empty():
             UpperCamelCase__    :     int        =						node
        else:
             assert isinstance(self.rear							,     SCREAMING_SNAKE_CASE		)
             UpperCamelCase__    :     Dict        =						node
             UpperCamelCase__    :     str        =						node
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     Dict		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        if self.is_empty():
             raise IndexError("dequeue from empty queue"		)
        assert isinstance(self.front							,     SCREAMING_SNAKE_CASE		)
        UpperCamelCase__    :     Optional[int]        =						self.front
        UpperCamelCase__    :     List[str]        =						self.front.next
        if self.front is None:
             UpperCamelCase__    :     List[Any]        =						None
        return node.data
  
  
  
  
  
  
  
   def       __lowercase      (	self      :     str		):
  
  
        '''simple docstring'''
  
  
  
  
  
  
        UpperCamelCase__    :     Optional[int]        =						None
  
  
  if __name__ == "__main__":
   from doctest import testmod
  
   testmod()