from timeit import timeit



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







    if number < 0:
        raise ValueError('''the value of input must not be negative'''	)
    __UpperCamelCase     :str			  =		0
    while number:
        number &= number - 1
        result += 1
    return result



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







    if number < 0:
        raise ValueError('''the value of input must not be negative'''	)
    __UpperCamelCase     :Optional[Any]			  =		0
    while number:
        if number % 2 == 1:
            result += 1
        number >>= 1
    return result



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







    def do_benchmark(SCREAMING_SNAKE_CASE	) -> None:
        __UpperCamelCase     :List[str]			  =		'''import __main__ as z'''
        print(f"""Benchmark when {number = }:"""	)
        print(f"""{get_set_bits_count_using_modulo_operator(SCREAMING_SNAKE_CASE	) = }"""	)
        __UpperCamelCase     :Optional[int]			  =		timeit('''z.get_set_bits_count_using_modulo_operator(25)'''  ,			setup=SCREAMING_SNAKE_CASE	)
        print(f"""timeit() runs in {timing} seconds"""	)
        print(f"""{get_set_bits_count_using_brian_kernighans_algorithm(SCREAMING_SNAKE_CASE	) = }"""	)
        __UpperCamelCase     :Union[str, Any]			  =		timeit(
            '''z.get_set_bits_count_using_brian_kernighans_algorithm(25)'''  ,			setup=SCREAMING_SNAKE_CASE  ,			)
        print(f"""timeit() runs in {timing} seconds"""	)

    for number in (25, 37, 58, 0):
        do_benchmark(SCREAMING_SNAKE_CASE	)
        print()


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    benchmark()






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)





