






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 				snake_case__							(							UpperCAmelCase							:  Tuple    ,			UpperCAmelCase							:  Optional[int]    ,			UpperCAmelCase							:  List[str]    ,			UpperCAmelCase							:  Any       ):
    # Initialise PyTorch model
    lowerCAmelCase__   :List[Any]      							=				FunnelConfig.from_json_file(UpperCAmelCase       )
    print(F'''Building PyTorch model from configuration: {config}'''       )
    lowerCAmelCase__   :List[str]      							=				FunnelBaseModel(UpperCAmelCase       ) if base_model else FunnelModel(UpperCAmelCase       )

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

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


if __name__ == "__main__":
 _a        =			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."""
 )
 _a        =			parser.parse_args()
 convert_tf_checkpoint_to_pytorch(
     args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.base_model
 )











from __future__ import annotations

import numpy as np


def 				snake_case__							(							UpperCAmelCase							:  np.ndarray       ):
    lowerCAmelCase__							,lowerCAmelCase__   :List[str]      							=				np.shape(UpperCAmelCase       )
    if rows != columns:
        lowerCAmelCase__   :Tuple      							=				(
            "'table' has to be of square shaped array but got a "
            F'''{rows}x{columns} array:\n{table}'''
        )
        raise ValueError(UpperCAmelCase       )

    lowerCAmelCase__   :Optional[Any]      							=				np.zeros((rows, columns)       )
    lowerCAmelCase__   :Tuple      							=				np.zeros((rows, columns)       )
    for i in range(UpperCAmelCase       ):
        for j in range(UpperCAmelCase       ):
            lowerCAmelCase__   :Any      							=				sum(lower[i][k] * upper[k][j] for k in range(UpperCAmelCase       )       )
            if upper[j][j] == 0:
                raise ArithmeticError("No LU decomposition exists"       )
            lowerCAmelCase__   :Any      							=				(table[i][j] - total) / upper[j][j]
        lowerCAmelCase__   :Tuple      							=				1
        for j in range(UpperCAmelCase    ,			UpperCAmelCase       ):
            lowerCAmelCase__   :Optional[Any]      							=				sum(lower[i][k] * upper[k][j] for k in range(UpperCAmelCase       )       )
            lowerCAmelCase__   :Dict      							=				table[i][j] - total
    return lower, upper


if __name__ == "__main__":
 import doctest

 doctest.testmod()



