





'''simple docstring'''






import argparse
import os
import re

import tensorflow as tf
import torch

from transformers import BertConfig, BertModel
from transformers.utils import logging


logging.set_verbosity_info()
lowerCAmelCase       		=      logging.get_logger(__name__)






def      __A						(							a_						:  int      ,a_						:  Dict      ,a_						:  Optional[int]	):
		lowerCAmelCase     :    Optional[int]						=   os.path.abspath(a_	)
		logger.info(f'''Converting TensorFlow checkpoint from {tf_path}'''	)
		# Load weights from TF model
		lowerCAmelCase     :    str						=   tf.train.list_variables(a_	)
		lowerCAmelCase     :    Union[str, Any]						=   []
		lowerCAmelCase     :    int						=   []
		lowerCAmelCase     :    List[str]						=   []
		for full_name, shape in init_vars:
				# logger.info(f"Loading TF weight {name} with shape {shape}")
				lowerCAmelCase     :    Optional[Any]						=   full_name.split("/"	)
				if full_name == "_CHECKPOINTABLE_OBJECT_GRAPH" or name[0] in ["global_step", "save_counter"]:
						logger.info(f'''Skipping non-model layer {full_name}'''	)
						continue
				if "optimizer" in full_name:
						logger.info(f'''Skipping optimization layer {full_name}'''	)
						continue
				if name[0] == "model":
						# ignore initial 'model'
						lowerCAmelCase     :    Optional[int]						=   name[1:]
				# figure out how many levels deep the name is
				lowerCAmelCase     :    Tuple						=   0
				for _name in name:
						if _name.startswith("layer_with_weights"	):
								depth += 1
						else:
								break
				layer_depth.append(a_	)
				# read data
				lowerCAmelCase     :    Dict						=   tf.train.load_variable(a_      ,a_	)
				names.append("/".join(a_	)	)
				arrays.append(a_	)
		logger.info(f'''Read a total of {len(a_	):,} layers'''	)

		# Sanity check
		if len(set(a_	)	) != 1:
				raise ValueError(f'''Found layer names with different depths (layer depth {list(set(a_	)	)})'''	)
		lowerCAmelCase     :    Dict						=   list(set(a_	)	)[0]
		if layer_depth != 1:
				raise ValueError(
				    "The model contains more than just the embedding/encoder layers. This script does not handle MLM/NSP"
				    " heads."	)

		# convert layers
		logger.info("Converting weights..."	)
		for full_name, array in zip(a_      ,a_	):
				lowerCAmelCase     :    Any						=   full_name.split("/"	)
				lowerCAmelCase     :    Optional[Any]						=   model
				lowerCAmelCase     :    Dict						=   []
				for i, m_name in enumerate(a_	):
						if m_name == ".ATTRIBUTES":
								# variable names end with .ATTRIBUTES/VARIABLE_VALUE
								break
						if m_name.startswith("layer_with_weights"	):
								lowerCAmelCase     :    Union[str, Any]						=   int(m_name.split("-"	)[-1]	)
								if layer_num <= 2:
										# embedding layers
										# layer_num 0: word_embeddings
										# layer_num 1: position_embeddings
										# layer_num 2: token_type_embeddings
										continue
								elif layer_num == 3:
										# embedding LayerNorm
										trace.extend(["embeddings", "LayerNorm"]	)
										lowerCAmelCase     :    List[str]						=   getattr(a_      ,"embeddings"	)
										lowerCAmelCase     :    Any						=   getattr(a_      ,"LayerNorm"	)
								elif layer_num > 3 and layer_num < config.num_hidden_layers + 4:
										# encoder layers
										trace.extend(["encoder", "layer", str(layer_num - 4	)]	)
										lowerCAmelCase     :    Optional[int]						=   getattr(a_      ,"encoder"	)
										lowerCAmelCase     :    str						=   getattr(a_      ,"layer"	)
										lowerCAmelCase     :    Optional[int]						=   pointer[layer_num - 4]
								elif layer_num == config.num_hidden_layers + 4:
										# pooler layer
										trace.extend(["pooler", "dense"]	)
										lowerCAmelCase     :    Tuple						=   getattr(a_      ,"pooler"	)
										lowerCAmelCase     :    Union[str, Any]						=   getattr(a_      ,"dense"	)
						elif m_name == "embeddings":
								trace.append("embeddings"	)
								lowerCAmelCase     :    Dict						=   getattr(a_      ,"embeddings"	)
								if layer_num == 0:
										trace.append("word_embeddings"	)
										lowerCAmelCase     :    Optional[Any]						=   getattr(a_      ,"word_embeddings"	)
								elif layer_num == 1:
										trace.append("position_embeddings"	)
										lowerCAmelCase     :    Optional[Any]						=   getattr(a_      ,"position_embeddings"	)
								elif layer_num == 2:
										trace.append("token_type_embeddings"	)
										lowerCAmelCase     :    List[Any]						=   getattr(a_      ,"token_type_embeddings"	)
								else:
										raise ValueError(f'''Unknown embedding layer with name {full_name}'''	)
								trace.append("weight"	)
								lowerCAmelCase     :    List[str]						=   getattr(a_      ,"weight"	)
						elif m_name == "_attention_layer":
								# self-attention layer
								trace.extend(["attention", "self"]	)
								lowerCAmelCase     :    Tuple						=   getattr(a_      ,"attention"	)
								lowerCAmelCase     :    List[str]						=   getattr(a_      ,"self"	)
						elif m_name == "_attention_layer_norm":
								# output attention norm
								trace.extend(["attention", "output", "LayerNorm"]	)
								lowerCAmelCase     :    str						=   getattr(a_      ,"attention"	)
								lowerCAmelCase     :    List[str]						=   getattr(a_      ,"output"	)
								lowerCAmelCase     :    Optional[int]						=   getattr(a_      ,"LayerNorm"	)
						elif m_name == "_attention_output_dense":
								# output attention dense
								trace.extend(["attention", "output", "dense"]	)
								lowerCAmelCase     :    Optional[Any]						=   getattr(a_      ,"attention"	)
								lowerCAmelCase     :    int						=   getattr(a_      ,"output"	)
								lowerCAmelCase     :    Optional[Any]						=   getattr(a_      ,"dense"	)
						elif m_name == "_output_dense":
								# output dense
								trace.extend(["output", "dense"]	)
								lowerCAmelCase     :    Dict						=   getattr(a_      ,"output"	)
								lowerCAmelCase     :    str						=   getattr(a_      ,"dense"	)
						elif m_name == "_output_layer_norm":
								# output dense
								trace.extend(["output", "LayerNorm"]	)
								lowerCAmelCase     :    Any						=   getattr(a_      ,"output"	)
								lowerCAmelCase     :    Union[str, Any]						=   getattr(a_      ,"LayerNorm"	)
						elif m_name == "_key_dense":
								# attention key
								trace.append("key"	)
								lowerCAmelCase     :    Optional[int]						=   getattr(a_      ,"key"	)
						elif m_name == "_query_dense":
								# attention query
								trace.append("query"	)
								lowerCAmelCase     :    List[str]						=   getattr(a_      ,"query"	)
						elif m_name == "_value_dense":
								# attention value
								trace.append("value"	)
								lowerCAmelCase     :    str						=   getattr(a_      ,"value"	)
						elif m_name == "_intermediate_dense":
								# attention intermediate dense
								trace.extend(["intermediate", "dense"]	)
								lowerCAmelCase     :    Dict						=   getattr(a_      ,"intermediate"	)
								lowerCAmelCase     :    Tuple						=   getattr(a_      ,"dense"	)
						elif m_name == "_output_layer_norm":
								# output layer norm
								trace.append("output"	)
								lowerCAmelCase     :    Dict						=   getattr(a_      ,"output"	)
						# weights & biases
						elif m_name in ["bias", "beta"]:
								trace.append("bias"	)
								lowerCAmelCase     :    int						=   getattr(a_      ,"bias"	)
						elif m_name in ["kernel", "gamma"]:
								trace.append("weight"	)
								lowerCAmelCase     :    str						=   getattr(a_      ,"weight"	)
						else:
								logger.warning(f'''Ignored {m_name}'''	)
        # for certain layers reshape is necessary
				lowerCAmelCase     :    Optional[Any]						=   ".".join(a_	)
				if re.match(R"(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)"      ,a_	) or re.match(
				    R"(\S+)\.attention\.output\.dense\.weight"      ,a_	):
						lowerCAmelCase     :    List[str]						=   array.reshape(pointer.data.shape	)
				if "kernel" in full_name:
						lowerCAmelCase     :    Dict						=   array.transpose()
				if pointer.shape == array.shape:
						lowerCAmelCase     :    Tuple						=   torch.from_numpy(a_	)
				else:
						raise ValueError(
						    f'''Shape mismatch in layer {full_name}: Model expects shape {pointer.shape} but layer contains shape:'''
						    f''' {array.shape}'''	)
				logger.info(f'''Successfully set variable {full_name} to PyTorch layer {trace}'''	)
		return model






def      __A						(							a_						:  Tuple      ,a_						:  List[Any]      ,a_						:  List[Any]	):
		# Instantiate model
		logger.info(f'''Loading model based on config from {config_path}...'''	)
		lowerCAmelCase     :    Any						=   BertConfig.from_json_file(a_	)
		lowerCAmelCase     :    Any						=   BertModel(a_	)

		# Load weights from checkpoint
		logger.info(f'''Loading weights from checkpoint {tf_checkpoint_path}...'''	)
		load_tfa_weights_in_bert(a_      ,a_      ,a_	)

		# Save pytorch-model
		logger.info(f'''Saving PyTorch model to {pytorch_dump_path}...'''	)
		torch.save(model.state_dict()      ,a_	)


if __name__ == "__main__":
					lowerCAmelCase       		=      argparse.ArgumentParser()
					parser.add_argument(
					    """--tf_checkpoint_path""", type=str, required=True, help="""Path to the TensorFlow 2.x checkpoint path."""
					)
					parser.add_argument(
					    """--bert_config_file""",
					    type=str,
					    required=True,
					    help="""The config json file corresponding to the BERT model. This specifies the model architecture.""",
					)
					parser.add_argument(
					    """--pytorch_dump_path""",
					    type=str,
					    required=True,
					    help="""Path to the output PyTorch model (must include filename).""",
					)
					lowerCAmelCase       		=      parser.parse_args()
					convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)










'''simple docstring'''






def      __A						(							a_						:  int      ,a_						:  int	):
		return abs(a_	) if a == 0 else greatest_common_divisor(b % a      ,a_	)






def      __A						(							a_						:  int      ,a_						:  int	):
		while y:  # --> when y=0 then loop will terminate and return x as final GCD.
				lowerCAmelCase	,		lowerCAmelCase     :    Tuple						=   y, x % y
		return abs(a_	)






def      __A						(							):
		try:
				lowerCAmelCase     :    Tuple						=   input("Enter two integers separated by comma (,): "	).split(","	)
				lowerCAmelCase     :    Tuple						=   int(nums[0]	)
				lowerCAmelCase     :    Tuple						=   int(nums[1]	)
				print(
				    f'''greatest_common_divisor({num_a}, {num_a}) = '''
				    f'''{greatest_common_divisor(a_      ,a_	)}'''	)
				print(f'''By iterative gcd({num_a}, {num_a}) = {gcd_by_iterative(a_      ,a_	)}'''	)
		except (IndexError, UnboundLocalError, ValueError):
				print("Wrong input"	)


if __name__ == "__main__":
					main()



