





import functools
from math import sqrt
from time import time





def 							__lowerCAmelCase(					_SCREAMING_SNAKE_CASE       ,    *_SCREAMING_SNAKE_CASE       ,    **_SCREAMING_SNAKE_CASE							)       ->   Tuple:




    """simple docstring"""




    _A    =       time()
    _A    =       func(*_SCREAMING_SNAKE_CASE       ,    **_SCREAMING_SNAKE_CASE							)
    _A    =       time()
    if int(end - start							) > 0:
        print(F"{func.__name__} runtime: {(end - start):0.4f} s"							)
    else:
        print(F"{func.__name__} runtime: {(end - start) * 1_000:0.4f} ms"							)
    return output





def 							__lowerCAmelCase(					_SCREAMING_SNAKE_CASE							)       ->   list[int]:




    """simple docstring"""




    if n < 0:
        raise Exception('n is negative'							)
    if n == 0:
        return [0]
    _A    =       [0, 1]
    for _ in range(n - 1							):
        fib.append(fib[-1] + fib[-2]							)
    return fib





def 							__lowerCAmelCase(					_SCREAMING_SNAKE_CASE							)       ->   list[int]:




    """simple docstring"""




    def fib_recursive_term(_SCREAMING_SNAKE_CASE							) -> int:
        if i < 0:
            raise Exception('n is negative'							)
        if i < 2:
            return i
        return fib_recursive_term(i - 1							) + fib_recursive_term(i - 2							)

    if n < 0:
        raise Exception('n is negative'							)
    return [fib_recursive_term(_SCREAMING_SNAKE_CASE							) for i in range(n + 1							)]





def 							__lowerCAmelCase(					_SCREAMING_SNAKE_CASE							)       ->   list[int]:




    """simple docstring"""




    @functools.cache
    def fib_recursive_term(_SCREAMING_SNAKE_CASE							) -> int:
        if i < 0:
            raise Exception('n is negative'							)
        if i < 2:
            return i
        return fib_recursive_term(i - 1							) + fib_recursive_term(i - 2							)

    if n < 0:
        raise Exception('n is negative'							)
    return [fib_recursive_term(_SCREAMING_SNAKE_CASE							) for i in range(n + 1							)]





def 							__lowerCAmelCase(					_SCREAMING_SNAKE_CASE							)       ->   list[int]:




    """simple docstring"""




    if n < 0:
        raise Exception('n is negative'							)
    # Cache must be outside recursuive function
    # other it will reset every time it calls itself.
    _A    =       {0: 0, 1: 1, 2: 1}  # Prefilled cache

    def rec_fn_memoized(_SCREAMING_SNAKE_CASE							) -> int:
        if num in cache:
            return cache[num]

        _A    =       rec_fn_memoized(num - 1							) + rec_fn_memoized(num - 2							)
        _A    =       value
        return value

    return [rec_fn_memoized(_SCREAMING_SNAKE_CASE							) for i in range(n + 1							)]





def 							__lowerCAmelCase(					_SCREAMING_SNAKE_CASE							)       ->   list[int]:




    """simple docstring"""




    if n < 0:
        raise Exception('n is negative'							)
    if n >= 1_475:
        raise Exception('n is too large'							)
    _A    =       sqrt(5							)
    _A    =       (1 + sqrt_a) / 2
    return [round(phi**i / sqrt_a							) for i in range(n + 1							)]


if __name__ == "__main__":
 __A       : Union[str, Any]						    = 30
 time_func(fib_iterative, num)
 time_func(fib_recursive, num)  # Around 3s runtime
 time_func(fib_recursive_cached, num)  # Around 0ms runtime
 time_func(fib_memoization, num)
 time_func(fib_binet, num)












import argparse

import torch
from flax.training.checkpoints import restore_checkpoint

from transformers import FNetConfig, FNetForPreTraining
from transformers.utils import logging


logging.set_verbosity_info()





def 							__lowerCAmelCase(					_SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE							)       ->   List[str]:




    """simple docstring"""




    _A    =       FNetConfig.from_json_file(_SCREAMING_SNAKE_CASE							)
    print(F"Building PyTorch model from configuration: {config}"							)
    _A    =       FNetForPreTraining(_SCREAMING_SNAKE_CASE							)

    _A    =       restore_checkpoint(_SCREAMING_SNAKE_CASE       ,    _SCREAMING_SNAKE_CASE							)
    _A    =       checkpoint_dict['target']

    # Embeddings
    # Position IDs
    _A    =       fnet_pretraining_model.state_dict()

    _A    =       state_dict['fnet.embeddings.position_ids']
    _A    =       {'fnet.embeddings.position_ids': position_ids}
    # Embedding Layers
    _A    =       torch.tensor(
        pretrained_model_params['encoder']['embedder']['word']['embedding']							)
    _A    =       torch.tensor(
        pretrained_model_params['encoder']['embedder']['position']['embedding'][0]							)
    _A    =       torch.tensor(
        pretrained_model_params['encoder']['embedder']['type']['embedding']							)
    _A    =       torch.tensor(
        pretrained_model_params['encoder']['embedder']['hidden_mapping_in']['kernel']							).T
    _A    =       torch.tensor(
        pretrained_model_params['encoder']['embedder']['hidden_mapping_in']['bias']							)
    _A    =       torch.tensor(
        pretrained_model_params['encoder']['embedder']['layer_norm']['scale']							)
    _A    =       torch.tensor(
        pretrained_model_params['encoder']['embedder']['layer_norm']['bias']							)

    # Encoder Layers
    for layer in range(config.num_hidden_layers							):
        _A    =       torch.tensor(
            pretrained_model_params['encoder'][F"encoder_{layer}"]['mixing_layer_norm']['scale']							)
        _A    =       torch.tensor(
            pretrained_model_params['encoder'][F"encoder_{layer}"]['mixing_layer_norm']['bias']							)

        _A    =       torch.tensor(
            pretrained_model_params['encoder'][F"feed_forward_{layer}"]['intermediate']['kernel']							).T
        _A    =       torch.tensor(
            pretrained_model_params['encoder'][F"feed_forward_{layer}"]['intermediate']['bias']							)

        _A    =       torch.tensor(
            pretrained_model_params['encoder'][F"feed_forward_{layer}"]['output']['kernel']							).T
        _A    =       torch.tensor(
            pretrained_model_params['encoder'][F"feed_forward_{layer}"]['output']['bias']							)

        _A    =       torch.tensor(
            pretrained_model_params['encoder'][F"encoder_{layer}"]['output_layer_norm']['scale']							)
        _A    =       torch.tensor(
            pretrained_model_params['encoder'][F"encoder_{layer}"]['output_layer_norm']['bias']							)

    # Pooler Layers
    _A    =       torch.tensor(pretrained_model_params['encoder']['pooler']['kernel']							).T
    _A    =       torch.tensor(pretrained_model_params['encoder']['pooler']['bias']							)

    # Masked LM Layers
    _A    =       torch.tensor(
        pretrained_model_params['predictions_dense']['kernel']							).T
    _A    =       torch.tensor(
        pretrained_model_params['predictions_dense']['bias']							)
    _A    =       torch.tensor(
        pretrained_model_params['predictions_layer_norm']['scale']							)
    _A    =       torch.tensor(
        pretrained_model_params['predictions_layer_norm']['bias']							)
    _A    =       torch.tensor(
        pretrained_model_params['encoder']['embedder']['word']['embedding']							)
    _A    =       torch.tensor(
        pretrained_model_params['predictions_output']['output_bias']							)
    _A    =       torch.tensor(pretrained_model_params['predictions_output']['output_bias']							)

    # Seq Relationship Layers
    _A    =       torch.tensor(
        pretrained_model_params['classification']['output_kernel']							)
    _A    =       torch.tensor(
        pretrained_model_params['classification']['output_bias']							)

    # Load State Dict
    fnet_pretraining_model.load_state_dict(_SCREAMING_SNAKE_CASE							)

    # Save PreTrained
    print(F"Saving pretrained model to {save_path}"							)
    fnet_pretraining_model.save_pretrained(_SCREAMING_SNAKE_CASE							)


if __name__ == "__main__":
 __A       : str						    = argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     "--flax_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
 )
 parser.add_argument(
     "--fnet_config_file",
     default=None,
     type=str,
     required=True,
     help=(
         "The config json file corresponding to the pre-trained FNet model. \n"
         "This specifies the model architecture."
     ),
 )
 parser.add_argument("--save_path", default=None, type=str, required=True, help="Path to the output model.")
 __A       : Any						    = parser.parse_args()
 convert_flax_checkpoint_to_pytorch(args.flax_checkpoint_path, args.fnet_config_file, args.save_path)





