def lowerCamelCase  (   SCREAMING_SNAKE_CASE	):
    '''simple docstring'''







    try:
        __UpperCamelCase     :int			  =		float(SCREAMING_SNAKE_CASE	)
    except ValueError:
        raise ValueError('''Please enter a valid number'''	)
    __UpperCamelCase     :int			  =		decimal - int(SCREAMING_SNAKE_CASE	)
    if fractional_part == 0:
        return int(SCREAMING_SNAKE_CASE	), 1
    else:
        __UpperCamelCase     :Union[str, Any]			  =		len(str(SCREAMING_SNAKE_CASE	).split('''.'''	)[1]	)
        __UpperCamelCase     :List[Any]			  =		int(decimal * (10**number_of_frac_digits)	)
        __UpperCamelCase     :Dict			  =		10**number_of_frac_digits
        __UpperCamelCase  ,       __UpperCamelCase     :Optional[int]			  =		denominator, numerator
        while True:
            __UpperCamelCase     :Optional[Any]			  =		dividend % divisor
            if remainder == 0:
                break
            __UpperCamelCase  ,       __UpperCamelCase     :Optional[int]			  =		divisor, remainder
        __UpperCamelCase  ,       __UpperCamelCase     :Union[str, Any]			  =		numerator / divisor, denominator / divisor
        return int(SCREAMING_SNAKE_CASE	), int(SCREAMING_SNAKE_CASE	)


if __name__ == "__main__":
    print(F'{decimal_to_fraction(2) = }')
    print(F'{decimal_to_fraction(8_9.0) = }')
    print(F'{decimal_to_fraction("67") = }')
    print(F'{decimal_to_fraction("45.0") = }')
    print(F'{decimal_to_fraction(1.5) = }')
    print(F'{decimal_to_fraction("6.25") = }')
    print(F'{decimal_to_fraction("78td") = }')






import argparse

import torch

from ...utils import logging
from . import AlbertConfig, AlbertForPreTraining, load_tf_weights_in_albert


logging.set_verbosity_info()



def lowerCamelCase  (   SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE	):
    '''simple docstring'''







    __UpperCamelCase     :List[Any]			  =		AlbertConfig.from_json_file(SCREAMING_SNAKE_CASE	)
    print(f"""Building PyTorch model from configuration: {config}"""	)
    __UpperCamelCase     :List[str]			  =		AlbertForPreTraining(SCREAMING_SNAKE_CASE	)

    # Load weights from tf checkpoint
    load_tf_weights_in_albert(SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE  ,			SCREAMING_SNAKE_CASE	)

    # Save pytorch-model
    print(f"""Save PyTorch model to {pytorch_dump_path}"""	)
    torch.save(model.state_dict()  ,			SCREAMING_SNAKE_CASE	)


if __name__ == "__main__":
    __lowercase							 =					argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.'''
    )
    parser.add_argument(
        '''--albert_config_file''',
        default=None,
        type=str,
        required=True,
        help=(
            '''The config json file corresponding to the pre-trained ALBERT model. \n'''
            '''This specifies the model architecture.'''
        ),
    )
    parser.add_argument(
        '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
    )
    __lowercase							 =					parser.parse_args()
    convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.albert_config_file, args.pytorch_dump_path)





