



import argparse

import torch

from transformers import FunnelBaseModel, FunnelConfig, FunnelModel, load_tf_weights_in_funnel
from transformers.utils import logging


logging.set_verbosity_info()



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_					) ->    List[str]:
			lowercase__   					=			FunnelConfig.from_json_file(A__					)
			print(f'''Building PyTorch model from configuration: {config}'''					)
			lowercase__   					=			FunnelBaseModel(A__					) if base_model else FunnelModel(A__					)

			# Load weights from tf checkpoint
			load_tf_weights_in_funnel(A__  ,					A__  ,					A__					)

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


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(
							    """--config_file""",
							    default=None,
							    type=str,
							    required=True,
							    help="""The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.""",
							)
							parser.add_argument(
							    """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
							)
							parser.add_argument(
							    """--base_model""", action="""store_true""", help="""Whether you want just the base model (no decoder) or not."""
							)
							lowercase_						=       parser.parse_args()
							convert_tf_checkpoint_to_pytorch(
							    args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.base_model
							)









def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_					):
			lowercase__   					=			1  # To kept the Calculated Value
			# Since C(n, k) = C(n, n-k)
			if k > (n - k):
						lowercase__   					=			n - k
			# Calculate C(n,k)
			for i in range(SCREAMING_SNAKE_CASE_					):
						result *= n - i
						result //= i + 1
			return result



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			return binomial_coefficient(2 * node_count  ,					SCREAMING_SNAKE_CASE_					) // (node_count + 1)



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			if n < 0:
						raise ValueError("factorial() not defined for negative values"					)
			lowercase__   					=			1
			for i in range(1  ,					n + 1					):
						result *= i
			return result



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			return catalan_number(SCREAMING_SNAKE_CASE_					) * factorial(SCREAMING_SNAKE_CASE_					)


if __name__ == "__main__":
							lowercase_						=       int(input("""Enter the number of nodes: """).strip() or 0)
							if node_count <= 0:
														raise ValueError("""We need some nodes to work with.""")
							print(
							    F'Given {node_count} nodes, there are {binary_tree_count(node_count)} '
							    F'binary trees and {catalan_number(node_count)} binary search trees.'
							)




