





'''simple docstring'''


def       __snake_case		( SCREAMING_SNAKE_CASE_ :			int )							->     list:

       """simple docstring"""


       if bit_count < 0:
              raise ValueError('''The given input must be positive''' )

       # get the generated string sequence
       UpperCAmelCase  =						gray_code_sequence_string(SCREAMING_SNAKE_CASE_ )
       #
       # convert them to integers
       for i in range(len(SCREAMING_SNAKE_CASE_ ) ):
              UpperCAmelCase  =						int(sequence[i]			,	2 )

       return sequence
def       __snake_case		( SCREAMING_SNAKE_CASE_ :			int )							->     list:

       """simple docstring"""


       if bit_count == 0:
              return ["0"]

       if bit_count == 1:
              return ["0", "1"]

       UpperCAmelCase  =						1 << bit_count  # defines the length of the sequence
       # 1<< n is equivalent to 2^n

       # recursive answer will generate answer for n-1 bits
       UpperCAmelCase  =						gray_code_sequence_string(bit_count - 1 )

       UpperCAmelCase  =						[]

       # append 0 to first half of the smaller sequence generated
       for i in range(seq_len // 2 ):
              UpperCAmelCase  =						'''0''' + smaller_sequence[i]
              sequence.append(SCREAMING_SNAKE_CASE_ )

       # append 1 to second half ... start from the end of the list
       for i in reversed(range(seq_len // 2 ) ):
              UpperCAmelCase  =						'''1''' + smaller_sequence[i]
              sequence.append(SCREAMING_SNAKE_CASE_ )

       return sequence


if __name__ == "__main__":
    import doctest

    doctest.testmod()








import argparse
import os

import torch

from transformers.utils import WEIGHTS_NAME


a__		     =     ['''small''', '''medium''', '''large''']

a__		     =     '''lm_head.decoder.weight'''
a__		     =     '''lm_head.weight'''





def 				A__ (snake_case   :		str		,	snake_case   :		str				)     ->						Union[str, Any]:
					__UpperCamelCase					:	Union[str, Any]             =      torch.load(snake_case				)
					__UpperCamelCase					:	int             =      d.pop(snake_case				)
					os.makedirs(snake_case		,	exist_ok=snake_case				)
					torch.save(snake_case		,	os.path.join(snake_case		,	snake_case				)				)


if __name__ == "__main__":
	a__		     =     argparse.ArgumentParser()
	parser.add_argument('''--dialogpt_path''', default='''.''', type=str)
	a__		     =     parser.parse_args()
	for MODEL in DIALOGPT_MODELS:
		a__		     =     os.path.join(args.dialogpt_path, f"{MODEL}_ft.pkl")
		a__		     =     f"./DialoGPT-{MODEL}"
		convert_dialogpt_checkpoint(
		    checkpoint_path,
		    pytorch_dump_folder_path,
		)






