






import argparse

import torch

from transformers import OpenAIGPTConfig, OpenAIGPTModel, load_tf_weights_in_openai_gpt
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

def   _lowerCamelCase						(    __A     :				int		,		__A     :				int		,		__A     :				str			)   ->       List[Any]:



    if openai_config_file == "":
        _UpperCAmelCase					:   int      	=					OpenAIGPTConfig()
    else:
        _UpperCAmelCase					:   Optional[Any]      	=					OpenAIGPTConfig.from_json_file(_UpperCamelCase			)
    _UpperCAmelCase					:   Union[str, Any]      	=					OpenAIGPTModel(_UpperCamelCase			)

    # Load weights from numpy
    load_tf_weights_in_openai_gpt(_UpperCamelCase		,		_UpperCamelCase		,		_UpperCamelCase			)

    # Save pytorch-model
    _UpperCAmelCase					:   str      	=					pytorch_dump_folder_path + '''/''' + WEIGHTS_NAME
    _UpperCAmelCase					:   Optional[Any]      	=					pytorch_dump_folder_path + '''/''' + CONFIG_NAME
    print(f'''Save PyTorch model to {pytorch_weights_dump_path}'''			)
    torch.save(model.state_dict()		,		_UpperCamelCase			)
    print(f'''Save configuration file to {pytorch_config_dump_path}'''			)
    with open(_UpperCamelCase		,		'''w'''		,		encoding='''utf-8'''			) as f:
        f.write(config.to_json_string()			)


if __name__ == "__main__":
  SCREAMING_SNAKE_CASE							=    argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '--openai_checkpoint_folder_path',
      default=None,
      type=str,
      required=True,
      help='Path to the TensorFlow checkpoint path.',
  )
  parser.add_argument(
      '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
  )
  parser.add_argument(
      '--openai_config_file',
      default='',
      type=str,
      help=(
          'An optional config json file corresponding to the pre-trained OpenAI model. \n'
          'This specifies the model architecture.'
      ),
  )
  SCREAMING_SNAKE_CASE							=    parser.parse_args()
  convert_openai_checkpoint_to_pytorch(
      args.openai_checkpoint_folder_path, args.openai_config_file, args.pytorch_dump_folder_path
  )






"""simple docstring"""




from collections.abc import Callable




def 			_lowerCAmelCase		(		_UpperCamelCase			,					_UpperCamelCase			,					_UpperCamelCase    ):






  """simple docstring"""



  _lowercase:      float   			=  a
  _lowercase:      float   			=  b
  if function(_UpperCamelCase    ) == 0:  # one of the a or b is a root for the function
    return a
  elif function(_UpperCamelCase    ) == 0:
    return b
  elif (
      function(_UpperCamelCase    ) * function(_UpperCamelCase    ) > 0
  ):  # if none of these are root and they are both positive or negative,
    # then this algorithm can't find the root
    raise ValueError('''could not find root in given interval.'''    )
  else:
    _lowercase:      float   			=  start + (end - start) / 2.0
    while abs(start - mid    ) > 10**-7:  # until precisely equals to 10^-7
      if function(_UpperCamelCase    ) == 0:
        return mid
      elif function(_UpperCamelCase    ) * function(_UpperCamelCase    ) < 0:
        _lowercase:      Union[str, Any]   			=  mid
      else:
        _lowercase:      Any   			=  mid
      _lowercase:      List[Any]   			=  start + (end - start) / 2.0
    return mid




def 			_lowerCAmelCase		(		_UpperCamelCase    ):






  """simple docstring"""



  return x**3 - 2 * x - 5


if __name__ == "__main__":
  print(bisection(f, 1, 1_0_0_0))

  import doctest

  doctest.testmod()
