


'''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()
__A	:	Optional[Any]     =     logging.get_logger(__name__)





def      UpperCAmelCase      (		lowerCamelCase_  :List[str]				,      lowerCamelCase_  :Dict				,      lowerCamelCase_  :List[Any] ):







		'''simple docstring'''
		snake_case_		:							Optional[Any]			       =						os.path.abspath(lowerCamelCase_ )
		logger.info(F'''Converting TensorFlow checkpoint from {tf_path}''' )
		# Load weights from TF model
		snake_case_		:							Tuple			       =						tf.train.list_variables(lowerCamelCase_ )
		snake_case_		:							List[Any]			       =						[]
		snake_case_		:							Any			       =						[]
		snake_case_		:							Union[str, Any]			       =						[]
		for full_name, shape in init_vars:
				# logger.info(f"Loading TF weight {name} with shape {shape}")
				snake_case_		:							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'
						snake_case_		:							List[str]			       =						name[1:]
				# figure out how many levels deep the name is
				snake_case_		:							List[Any]			       =						0
				for _name in name:
						if _name.startswith("""layer_with_weights""" ):
								depth += 1
						else:
								break
				layer_depth.append(lowerCamelCase_ )
				# read data
				snake_case_		:							List[str]			       =						tf.train.load_variable(lowerCamelCase_				,      lowerCamelCase_ )
				names.append("""/""".join(lowerCamelCase_ ) )
				arrays.append(lowerCamelCase_ )
		logger.info(F'''Read a total of {len(lowerCamelCase_ ):,} layers''' )

		# Sanity check
		if len(set(lowerCamelCase_ ) ) != 1:
				raise ValueError(F'''Found layer names with different depths (layer depth {list(set(lowerCamelCase_ ) )})''' )
		snake_case_		:							Any			       =						list(set(lowerCamelCase_ ) )[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(lowerCamelCase_				,      lowerCamelCase_ ):
				snake_case_		:							List[Any]			       =						full_name.split("""/""" )
				snake_case_		:							str			       =						model
				snake_case_		:							str			       =						[]
				for i, m_name in enumerate(lowerCamelCase_ ):
						if m_name == ".ATTRIBUTES":
								# variable names end with .ATTRIBUTES/VARIABLE_VALUE
								break
						if m_name.startswith("""layer_with_weights""" ):
								snake_case_		:							List[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"""] )
										snake_case_		:							List[Any]			       =						getattr(lowerCamelCase_				,      """embeddings""" )
										snake_case_		:							Optional[Any]			       =						getattr(lowerCamelCase_				,      """LayerNorm""" )
								elif layer_num > 3 and layer_num < config.num_hidden_layers + 4:
										# encoder layers
										trace.extend(["""encoder""", """layer""", str(layer_num - 4 )] )
										snake_case_		:							Dict			       =						getattr(lowerCamelCase_				,      """encoder""" )
										snake_case_		:							int			       =						getattr(lowerCamelCase_				,      """layer""" )
										snake_case_		:							Optional[int]			       =						pointer[layer_num - 4]
								elif layer_num == config.num_hidden_layers + 4:
										# pooler layer
										trace.extend(["""pooler""", """dense"""] )
										snake_case_		:							Optional[int]			       =						getattr(lowerCamelCase_				,      """pooler""" )
										snake_case_		:							List[str]			       =						getattr(lowerCamelCase_				,      """dense""" )
						elif m_name == "embeddings":
								trace.append("""embeddings""" )
								snake_case_		:							Union[str, Any]			       =						getattr(lowerCamelCase_				,      """embeddings""" )
								if layer_num == 0:
										trace.append("""word_embeddings""" )
										snake_case_		:							Optional[int]			       =						getattr(lowerCamelCase_				,      """word_embeddings""" )
								elif layer_num == 1:
										trace.append("""position_embeddings""" )
										snake_case_		:							List[str]			       =						getattr(lowerCamelCase_				,      """position_embeddings""" )
								elif layer_num == 2:
										trace.append("""token_type_embeddings""" )
										snake_case_		:							List[Any]			       =						getattr(lowerCamelCase_				,      """token_type_embeddings""" )
								else:
										raise ValueError(F'''Unknown embedding layer with name {full_name}''' )
								trace.append("""weight""" )
								snake_case_		:							List[str]			       =						getattr(lowerCamelCase_				,      """weight""" )
						elif m_name == "_attention_layer":
								# self-attention layer
								trace.extend(["""attention""", """self"""] )
								snake_case_		:							List[Any]			       =						getattr(lowerCamelCase_				,      """attention""" )
								snake_case_		:							str			       =						getattr(lowerCamelCase_				,      """self""" )
						elif m_name == "_attention_layer_norm":
								# output attention norm
								trace.extend(["""attention""", """output""", """LayerNorm"""] )
								snake_case_		:							str			       =						getattr(lowerCamelCase_				,      """attention""" )
								snake_case_		:							Optional[Any]			       =						getattr(lowerCamelCase_				,      """output""" )
								snake_case_		:							Any			       =						getattr(lowerCamelCase_				,      """LayerNorm""" )
						elif m_name == "_attention_output_dense":
								# output attention dense
								trace.extend(["""attention""", """output""", """dense"""] )
								snake_case_		:							List[str]			       =						getattr(lowerCamelCase_				,      """attention""" )
								snake_case_		:							str			       =						getattr(lowerCamelCase_				,      """output""" )
								snake_case_		:							Optional[int]			       =						getattr(lowerCamelCase_				,      """dense""" )
						elif m_name == "_output_dense":
								# output dense
								trace.extend(["""output""", """dense"""] )
								snake_case_		:							int			       =						getattr(lowerCamelCase_				,      """output""" )
								snake_case_		:							List[str]			       =						getattr(lowerCamelCase_				,      """dense""" )
						elif m_name == "_output_layer_norm":
								# output dense
								trace.extend(["""output""", """LayerNorm"""] )
								snake_case_		:							List[Any]			       =						getattr(lowerCamelCase_				,      """output""" )
								snake_case_		:							Optional[Any]			       =						getattr(lowerCamelCase_				,      """LayerNorm""" )
						elif m_name == "_key_dense":
								# attention key
								trace.append("""key""" )
								snake_case_		:							str			       =						getattr(lowerCamelCase_				,      """key""" )
						elif m_name == "_query_dense":
								# attention query
								trace.append("""query""" )
								snake_case_		:							Any			       =						getattr(lowerCamelCase_				,      """query""" )
						elif m_name == "_value_dense":
								# attention value
								trace.append("""value""" )
								snake_case_		:							Union[str, Any]			       =						getattr(lowerCamelCase_				,      """value""" )
						elif m_name == "_intermediate_dense":
								# attention intermediate dense
								trace.extend(["""intermediate""", """dense"""] )
								snake_case_		:							Dict			       =						getattr(lowerCamelCase_				,      """intermediate""" )
								snake_case_		:							Tuple			       =						getattr(lowerCamelCase_				,      """dense""" )
						elif m_name == "_output_layer_norm":
								# output layer norm
								trace.append("""output""" )
								snake_case_		:							List[Any]			       =						getattr(lowerCamelCase_				,      """output""" )
						# weights & biases
						elif m_name in ["bias", "beta"]:
								trace.append("""bias""" )
								snake_case_		:							Tuple			       =						getattr(lowerCamelCase_				,      """bias""" )
						elif m_name in ["kernel", "gamma"]:
								trace.append("""weight""" )
								snake_case_		:							List[Any]			       =						getattr(lowerCamelCase_				,      """weight""" )
						else:
								logger.warning(F'''Ignored {m_name}''' )
        # for certain layers reshape is necessary
				snake_case_		:							int			       =						""".""".join(lowerCamelCase_ )
				if re.match(R"""(\S+)\.attention\.self\.(key|value|query)\.(bias|weight)"""				,      lowerCamelCase_ ) or re.match(
				    R"""(\S+)\.attention\.output\.dense\.weight"""				,      lowerCamelCase_ ):
						snake_case_		:							List[str]			       =						array.reshape(pointer.data.shape )
				if "kernel" in full_name:
						snake_case_		:							Dict			       =						array.transpose()
				if pointer.shape == array.shape:
						snake_case_		:							Union[str, Any]			       =						torch.from_numpy(lowerCamelCase_ )
				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      UpperCAmelCase      (		lowerCamelCase_  :Any				,      lowerCamelCase_  :Optional[Any]				,      lowerCamelCase_  :List[str] ):







		'''simple docstring'''
		logger.info(F'''Loading model based on config from {config_path}...''' )
		snake_case_		:							Tuple			       =						BertConfig.from_json_file(lowerCamelCase_ )
		snake_case_		:							Tuple			       =						BertModel(lowerCamelCase_ )

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

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


if __name__ == "__main__":
				__A	:	Optional[int]     =     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).',
				)
				__A	:	Any     =     parser.parse_args()
				convert_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)



'''simple docstring'''






from __future__ import annotations





def      UpperCAmelCase      (		lowerCamelCase_  :int ):







		'''simple docstring'''
		snake_case_		:							List[str]			       =						[True] * limit
		snake_case_		:							Union[str, Any]			       =						False
		snake_case_		:							List[str]			       =						False
		snake_case_		:							Any			       =						True

		for i in range(3				,      int(limit**0.5 + 1 )				,      2 ):
				snake_case_		:							Tuple			       =						i * 2
				while index < limit:
						snake_case_		:							Any			       =						False
						snake_case_		:							Optional[Any]			       =						index + i

		snake_case_		:							List[str]			       =						[2]

		for i in range(3				,      lowerCamelCase_				,      2 ):
				if is_prime[i]:
						primes.append(lowerCamelCase_ )

		return primes





def      UpperCAmelCase      (		lowerCamelCase_  :int = 1_00_00_00 ):







		'''simple docstring'''
		snake_case_		:							Optional[int]			       =						prime_sieve(lowerCamelCase_ )
		snake_case_		:							Optional[Any]			       =						0
		snake_case_		:							Optional[int]			       =						0

		for i in range(len(lowerCamelCase_ ) ):
				for j in range(i + length				,      len(lowerCamelCase_ ) ):
						snake_case_		:							Optional[int]			       =						sum(primes[i:j] )
						if sol >= ceiling:
								break

						if sol in primes:
								snake_case_		:							Optional[Any]			       =						j - i
								snake_case_		:							Tuple			       =						sol

		return largest


if __name__ == "__main__":
							print(F'{solution() = }')