




from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase_					    = logging.get_logger(__name__)

lowerCAmelCase_					    = {
    "funnel-transformer/small": "https://huggingface.co/funnel-transformer/small/resolve/main/config.json",
    "funnel-transformer/small-base": "https://huggingface.co/funnel-transformer/small-base/resolve/main/config.json",
    "funnel-transformer/medium": "https://huggingface.co/funnel-transformer/medium/resolve/main/config.json",
    "funnel-transformer/medium-base": "https://huggingface.co/funnel-transformer/medium-base/resolve/main/config.json",
    "funnel-transformer/intermediate": (
        "https://huggingface.co/funnel-transformer/intermediate/resolve/main/config.json"
    ),
    "funnel-transformer/intermediate-base": (
        "https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/config.json"
    ),
    "funnel-transformer/large": "https://huggingface.co/funnel-transformer/large/resolve/main/config.json",
    "funnel-transformer/large-base": "https://huggingface.co/funnel-transformer/large-base/resolve/main/config.json",
    "funnel-transformer/xlarge": "https://huggingface.co/funnel-transformer/xlarge/resolve/main/config.json",
    "funnel-transformer/xlarge-base": "https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/config.json",
}






class  _lowerCAmelCase     (  __lowerCAmelCase	):
      A__		     =		"funnel"
      A__		     =		{
          "hidden_size": "d_model",
          "num_attention_heads": "n_head",
      }

      def __init__(   self      ,				__UpperCAmelCase=3_0522      ,				__UpperCAmelCase=[4, 4, 4]      ,				__UpperCAmelCase=None      ,				__UpperCAmelCase=2      ,				__UpperCAmelCase=768      ,				__UpperCAmelCase=12      ,				__UpperCAmelCase=64      ,				__UpperCAmelCase=3072      ,				__UpperCAmelCase="gelu_new"      ,				__UpperCAmelCase=0.1      ,				__UpperCAmelCase=0.1      ,				__UpperCAmelCase=0.0      ,				__UpperCAmelCase=0.1      ,				__UpperCAmelCase=None      ,				__UpperCAmelCase=1e-9      ,				__UpperCAmelCase="mean"      ,				__UpperCAmelCase="relative_shift"      ,				__UpperCAmelCase=True      ,				__UpperCAmelCase=True      ,				__UpperCAmelCase=True      ,				**__UpperCAmelCase      ,				):
        lowerCAmelCase__				:  Optional[Any]		       =     vocab_size
        lowerCAmelCase__				:  int		       =     block_sizes
        lowerCAmelCase__				:  Tuple		       =     [1] * len(lowerCamelCase__		) if block_repeats is None else block_repeats
        assert len(lowerCamelCase__		) == len(
            self.block_repeats		), "`block_sizes` and `block_repeats` should have the same length."
        lowerCAmelCase__				:  str		       =     num_decoder_layers
        lowerCAmelCase__				:  Any		       =     d_model
        lowerCAmelCase__				:  Union[str, Any]		       =     n_head
        lowerCAmelCase__				:  Dict		       =     d_head
        lowerCAmelCase__				:  int		       =     d_inner
        lowerCAmelCase__				:  Union[str, Any]		       =     hidden_act
        lowerCAmelCase__				:  Any		       =     hidden_dropout
        lowerCAmelCase__				:  Any		       =     attention_dropout
        lowerCAmelCase__				:  str		       =     activation_dropout
        lowerCAmelCase__				:  int		       =     initializer_range
        lowerCAmelCase__				:  Optional[Any]		       =     initializer_std
        lowerCAmelCase__				:  Union[str, Any]		       =     layer_norm_eps
        assert pooling_type in [
            "mean",
            "max",
        ], f"""Got {pooling_type} for `pooling_type` but only 'mean' and 'max' are supported."""
        lowerCAmelCase__				:  Tuple		       =     pooling_type
        assert attention_type in [
            "relative_shift",
            "factorized",
        ], f"""Got {attention_type} for `attention_type` but only 'relative_shift' and 'factorized' are supported."""
        lowerCAmelCase__				:  Union[str, Any]		       =     attention_type
        lowerCAmelCase__				:  List[str]		       =     separate_cls
        lowerCAmelCase__				:  Any		       =     truncate_seq
        lowerCAmelCase__				:  int		       =     pool_q_only

        super().__init__(**lowerCamelCase__		)

      @property
      def 	__magic_name__(   self		):
        return sum(self.block_sizes		)

      @num_hidden_layers.setter
      def 	__magic_name__(   self      ,				__UpperCAmelCase		):
        raise NotImplementedError(
            '''This model does not support the setting of `num_hidden_layers`. Please set `block_sizes`.'''		)

      @property
      def 	__magic_name__(   self		):
        return len(self.block_sizes		)







      @num_blocks.setter
      def 	__magic_name__(   self      ,				__UpperCAmelCase		):
        raise NotImplementedError('''This model does not support the setting of `num_blocks`. Please set `block_sizes`.'''		)







def      __lowerCAmelCase			(					UpperCamelCase      )     ->	None:
  lowerCAmelCase__				:  Dict		       =     generate_pascal_triangle(UpperCamelCase      )
  for row_idx in range(UpperCamelCase      ):
    # Print left spaces
    for _ in range(num_rows - row_idx - 1      ):
      print(end=''' '''      )
    # Print row values
    for col_idx in range(row_idx + 1      ):
      if col_idx != row_idx:
        print(triangle[row_idx][col_idx]	,      end=''' '''      )
      else:
        print(triangle[row_idx][col_idx]	,      end=''''''      )
    print()



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

  if not isinstance(UpperCamelCase	,      UpperCamelCase      ):
    raise TypeError('''The input value of \'num_rows\' should be \'int\''''      )

  if num_rows == 0:
    return []
  elif num_rows < 0:
    raise ValueError(
        '''The input value of \'num_rows\' should be greater than or equal to 0'''      )

  lowerCAmelCase__				:  list[list[int]]		       =     []
  for current_row_idx in range(UpperCamelCase      ):
    lowerCAmelCase__				:  List[str]		       =     populate_current_row(UpperCamelCase	,      UpperCamelCase      )
    triangle.append(UpperCamelCase      )
  return triangle



def      __lowerCAmelCase			(					UpperCamelCase	,      UpperCamelCase      )     ->	list[int]:
  lowerCAmelCase__				:  Optional[Any]		       =     [-1] * (current_row_idx + 1)
  # first and last elements of current row are equal to 1
  lowerCAmelCase__       ,			lowerCAmelCase__				:  int		       =     1, 1
  for current_col_idx in range(1	,      UpperCamelCase      ):
    calculate_current_element(
        UpperCamelCase	,      UpperCamelCase	,      UpperCamelCase	,      UpperCamelCase      )
  return current_row



def      __lowerCAmelCase			(					UpperCamelCase	,      UpperCamelCase	,      UpperCamelCase	,      UpperCamelCase	,      )     ->	None:
  lowerCAmelCase__				:  Optional[int]		       =     triangle[current_row_idx - 1][current_col_idx - 1]
  lowerCAmelCase__				:  List[str]		       =     triangle[current_row_idx - 1][current_col_idx]
  lowerCAmelCase__				:  List[Any]		       =     above_to_left_elt + above_to_right_elt



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

  if not isinstance(UpperCamelCase	,      UpperCamelCase      ):
    raise TypeError('''The input value of \'num_rows\' should be \'int\''''      )

  if num_rows == 0:
    return []
  elif num_rows < 0:
    raise ValueError(
        '''The input value of \'num_rows\' should be greater than or equal to 0'''      )

  lowerCAmelCase__				:  list[list[int]]		       =     [[1]]

  for row_index in range(1	,      UpperCamelCase      ):
    lowerCAmelCase__				:  Optional[int]		       =     [0] + result[-1] + [0]
    lowerCAmelCase__				:  List[str]		       =     row_index + 1
    # Calculate the number of distinct elements in a row
    lowerCAmelCase__				:  Tuple		       =     sum(divmod(UpperCamelCase	,      2      )      )
    lowerCAmelCase__				:  Tuple		       =     [
        temp_row[i - 1] + temp_row[i] for i in range(1	,      distinct_elements + 1      )
    ]
    lowerCAmelCase__				:  int		       =     row_first_half[: (row_index + 1) // 2]
    row_second_half.reverse()
    lowerCAmelCase__				:  Dict		       =     row_first_half + row_second_half
    result.append(UpperCamelCase      )

  return result



def      __lowerCAmelCase			(					)     ->	None:
  from collections.abc import Callable
  from timeit import timeit

  def benchmark_a_function(UpperCamelCase	,      UpperCamelCase      ) -> None:
    lowerCAmelCase__				:  Tuple		       =     F"""{func.__name__}({value})"""
    lowerCAmelCase__				:  Dict		       =     timeit(F"""__main__.{call}"""	,      setup='''import __main__'''      )
    # print(f"{call:38} = {func(value)} -- {timing:.4f} seconds")
    print(F"""{call:38} -- {timing:.4f} seconds"""      )

  for value in range(15      ):  # (1, 7, 14):
    for func in (generate_pascal_triangle, generate_pascal_triangle_optimized):
      benchmark_a_function(UpperCamelCase	,      UpperCamelCase      )
    print()


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     benchmark()

