"""simple docstring"""


import argparse
import pickle

import numpy as np
import torch
from torch import nn

from transformers import ReformerConfig, ReformerModelWithLMHead
from transformers.utils import logging


logging.set_verbosity_info()




def 					lowercase__    (					lowercase_		,lowercase_		,lowercase_=None			)					->		Optional[int]:




      """simple docstring"""

      assert torch_layer.weight.shape == weight.shape, F'''{torch_layer} layer.weight does not match'''
      _UpperCamelCase      :	Optional[Any]						=       nn.Parameter(lowercase_			)
      if bias is not None:
            assert torch_layer.bias.shape == bias.shape, F'''{torch_layer} layer.bias does not match'''
            _UpperCamelCase      :	Optional[Any]						=       nn.Parameter(lowercase_			)




def 					lowercase__    (					lowercase_		,lowercase_		,lowercase_			)					->		List[str]:




      """simple docstring"""

      _UpperCamelCase      :	List[Any]						=       np.asarray(weights[0]			)
      _UpperCamelCase      :	Any						=       np.asarray(weights[1]			)
      _UpperCamelCase      :	str						=       np.asarray(weights[2]			)

      set_param(
          torch_layer.self_attention.query_key		,torch.tensor(lowercase_			).transpose(1		,2			).contiguous().view(-1		,lowercase_			)		,)
      set_param(
          torch_layer.self_attention.value		,torch.tensor(lowercase_			).transpose(1		,2			).contiguous().view(-1		,lowercase_			)		,)
      set_param(
          torch_layer.output.dense		,torch.tensor(lowercase_			).view(-1		,lowercase_			).contiguous().transpose(0		,1			)		,)




def 					lowercase__    (					lowercase_		,lowercase_		,lowercase_			)					->		int:




      """simple docstring"""

      _UpperCamelCase      :	int						=       np.asarray(weights[0]			)
      _UpperCamelCase      :	Optional[int]						=       np.asarray(weights[1]			)
      _UpperCamelCase      :	str						=       np.asarray(weights[2]			)
      _UpperCamelCase      :	List[str]						=       np.asarray(weights[3]			)

      set_param(
          torch_layer.self_attention.query		,torch.tensor(lowercase_			).transpose(1		,2			).contiguous().view(-1		,lowercase_			)		,)
      set_param(
          torch_layer.self_attention.key		,torch.tensor(lowercase_			).transpose(1		,2			).contiguous().view(-1		,lowercase_			)		,)
      set_param(
          torch_layer.self_attention.value		,torch.tensor(lowercase_			).transpose(1		,2			).contiguous().view(-1		,lowercase_			)		,)
      set_param(
          torch_layer.output.dense		,torch.tensor(lowercase_			).view(-1		,lowercase_			).contiguous().transpose(0		,1			)		,)




def 					lowercase__    (					lowercase_		,lowercase_		,lowercase_			)					->		Dict:




      """simple docstring"""

      _UpperCamelCase      :	Union[str, Any]						=       weights[0][0][0]
      _UpperCamelCase      :	Any						=       np.asarray(layer_norm_a[0]			)
      _UpperCamelCase      :	int						=       np.asarray(layer_norm_a[1]			)
      set_param(
          torch_block.attention.layer_norm		,torch.tensor(lowercase_			)		,torch.tensor(lowercase_			)		,)

      # lsh weights + output
      _UpperCamelCase      :	List[Any]						=       weights[0][1]
      if len(lowercase_			) < 4:
            set_layer_weights_in_torch_lsh(lowercase_		,torch_block.attention		,lowercase_			)
      else:
            set_layer_weights_in_torch_local(lowercase_		,torch_block.attention		,lowercase_			)

      # intermediate weighs
      _UpperCamelCase      :	Dict						=       weights[2][0][1][2]

      # Chunked Feed Forward
      if len(lowercase_			) == 4:
            _UpperCamelCase      :	Tuple						=       intermediate_weights[2]

      # layernorm 2
      _UpperCamelCase      :	int						=       np.asarray(intermediate_weights[0][0]			)
      _UpperCamelCase      :	Optional[int]						=       np.asarray(intermediate_weights[0][1]			)
      set_param(
          torch_block.feed_forward.layer_norm		,torch.tensor(lowercase_			)		,torch.tensor(lowercase_			)		,)

      # intermediate dense
      _UpperCamelCase      :	List[Any]						=       np.asarray(intermediate_weights[1][0]			)
      _UpperCamelCase      :	Tuple						=       np.asarray(intermediate_weights[1][1]			)
      set_param(
          torch_block.feed_forward.dense.dense		,torch.tensor(lowercase_			).transpose(0		,1			).contiguous()		,torch.tensor(lowercase_			)		,)

      # intermediate out
      _UpperCamelCase      :	Union[str, Any]						=       np.asarray(intermediate_weights[4][0]			)
      _UpperCamelCase      :	List[Any]						=       np.asarray(intermediate_weights[4][1]			)
      set_param(
          torch_block.feed_forward.output.dense		,torch.tensor(lowercase_			).transpose(0		,1			).contiguous()		,torch.tensor(lowercase_			)		,)




def 					lowercase__    (					lowercase_		,lowercase_		,lowercase_			)					->		List[Any]:




      """simple docstring"""

      _UpperCamelCase      :	Optional[Any]						=       torch_model.reformer

      # word embeds
      _UpperCamelCase      :	List[str]						=       np.asarray(weights[1]			)
      set_param(
          torch_model_reformer.embeddings.word_embeddings		,torch.tensor(lowercase_			)		,)

      if isinstance(weights[3]		,lowercase_			):
            _UpperCamelCase      :	Tuple						=       torch_model_reformer.embeddings.position_embeddings
            for emb_idx in range(len(position_embeddings.weights			)			):
                  _UpperCamelCase      :	List[str]						=       np.asarray(weights[3][emb_idx][0]			)
                  assert (
                      position_embeddings.weights[emb_idx].shape == emb_weights.shape
                  ), F'''{position_embeddings[emb_idx]} emb does not match'''
                  _UpperCamelCase      :	Dict						=       nn.Parameter(torch.tensor(lowercase_			)			)

      _UpperCamelCase      :	Optional[Any]						=       weights[5]
      assert len(torch_model_reformer.encoder.layers			) * 4 == len(
          lowercase_			), "HF and trax model do not have the same number of layers"
      for layer_idx, layer in enumerate(torch_model_reformer.encoder.layers			):
            _UpperCamelCase      :	List[Any]						=       trax_layer_weights[4 * layer_idx : 4 * (layer_idx + 1)]
            set_block_weights_in_torch(lowercase_		,lowercase_		,lowercase_			)

      # output layer norm
      _UpperCamelCase      :	int						=       np.asarray(weights[7][0]			)
      _UpperCamelCase      :	List[Any]						=       np.asarray(weights[7][1]			)
      set_param(
          torch_model_reformer.encoder.layer_norm		,torch.tensor(lowercase_			)		,torch.tensor(lowercase_			)		,)

      # output embeddings
      _UpperCamelCase      :	str						=       np.asarray(weights[9][0]			)
      _UpperCamelCase      :	Any						=       np.asarray(weights[9][1]			)
      set_param(
          torch_model.lm_head.decoder		,torch.tensor(lowercase_			).transpose(0		,1			).contiguous()		,torch.tensor(lowercase_			)		,)




def 					lowercase__    (					lowercase_		,lowercase_		,lowercase_			)					->		List[str]:




      """simple docstring"""

      _UpperCamelCase      :	Dict						=       ReformerConfig.from_json_file(lowercase_			)
      print(F'''Building PyTorch model from configuration: {config}'''			)
      _UpperCamelCase      :	Dict						=       ReformerModelWithLMHead(lowercase_			)

      with open(lowercase_		,"rb"			) as f:
            _UpperCamelCase      :	Optional[Any]						=       pickle.load(lowercase_			)["weights"]

      set_model_weights_in_torch(lowercase_		,lowercase_		,config.hidden_size			)

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


if __name__ == "__main__":
  lowerCamelCase__				  =   argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      "--trax_model_pkl_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 Reformer model. \n"
          "This specifies the model architecture."
      ),
  )
  parser.add_argument(
      "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
  )
  lowerCamelCase__				  =   parser.parse_args()
  convert_trax_checkpoint_to_pytorch(args.trax_model_pkl_path, args.config_file, args.pytorch_dump_path)







"""simple docstring"""


from collections import defaultdict
from math import ceil, sqrt




def 					lowercase__    (					lowercase_ = 1_000_000		,lowercase_ = 10			)					->		int:




      """simple docstring"""

      _UpperCamelCase      :	defaultdict						=       defaultdict(lowercase_			)

      for outer_width in range(3		,(t_limit // 4) + 2			):
            if outer_width * outer_width > t_limit:
                  _UpperCamelCase      :	Any						=       max(
                      ceil(sqrt(outer_width * outer_width - t_limit			)			)		,1			)
            else:
                  _UpperCamelCase      :	str						=       1

            hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

            for hole_width in range(lowercase_		,outer_width - 1		,2			):
                  count[outer_width * outer_width - hole_width * hole_width] += 1

      return sum(1 for n in count.values() if 1 <= n <= 10			)


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