


'''simple docstring'''

import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         NystromformerForMaskedLM,
         NystromformerForMultipleChoice,
         NystromformerForQuestionAnswering,
         NystromformerForSequenceClassification,
         NystromformerForTokenClassification,
         NystromformerModel,
     )
     from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST





class      snake_case    :





  """simple docstring"""




  def __init__(    self			,  UpperCamelCase			,  UpperCamelCase=13			,  UpperCamelCase=7			,  UpperCamelCase=True			,  UpperCamelCase=True			,  UpperCamelCase=True			,  UpperCamelCase=True			,  UpperCamelCase=99			,  UpperCamelCase=32			,  UpperCamelCase=5			,  UpperCamelCase=4			,  UpperCamelCase=37			,  UpperCamelCase="gelu"			,  UpperCamelCase=0.1			,  UpperCamelCase=0.1			,  UpperCamelCase=512			,  UpperCamelCase=16			,  UpperCamelCase=2			,  UpperCamelCase=0.02			,  UpperCamelCase=3			,  UpperCamelCase=4			,  UpperCamelCase=None			,  ):







   """simple docstring"""
   lowerCamelCase_      =  parent
   lowerCamelCase_      =  batch_size
   lowerCamelCase_      =  seq_length
   lowerCamelCase_      =  is_training
   lowerCamelCase_      =  use_input_mask
   lowerCamelCase_      =  use_token_type_ids
   lowerCamelCase_      =  use_labels
   lowerCamelCase_      =  vocab_size
   lowerCamelCase_      =  hidden_size
   lowerCamelCase_      =  num_hidden_layers
   lowerCamelCase_      =  num_attention_heads
   lowerCamelCase_      =  intermediate_size
   lowerCamelCase_      =  hidden_act
   lowerCamelCase_      =  hidden_dropout_prob
   lowerCamelCase_      =  attention_probs_dropout_prob
   lowerCamelCase_      =  max_position_embeddings
   lowerCamelCase_      =  type_vocab_size
   lowerCamelCase_      =  type_sequence_label_size
   lowerCamelCase_      =  initializer_range
   lowerCamelCase_      =  num_labels
   lowerCamelCase_      =  num_choices
   lowerCamelCase_      =  scope






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  ids_tensor([self.batch_size, self.seq_length]			,  self.vocab_size     )

   lowerCamelCase_      =  None
   if self.use_input_mask:
    lowerCamelCase_      =  random_attention_mask([self.batch_size, self.seq_length]     )

   lowerCamelCase_      =  None
   if self.use_token_type_ids:
    lowerCamelCase_      =  ids_tensor([self.batch_size, self.seq_length]			,  self.type_vocab_size     )

   lowerCamelCase_      =  None
   lowerCamelCase_      =  None
   lowerCamelCase_      =  None
   if self.use_labels:
    lowerCamelCase_      =  ids_tensor([self.batch_size]			,  self.type_sequence_label_size     )
    lowerCamelCase_      =  ids_tensor([self.batch_size, self.seq_length]			,  self.num_labels     )
    lowerCamelCase_      =  ids_tensor([self.batch_size]			,  self.num_choices     )

   lowerCamelCase_      =  self.get_config()

   return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






  def   snake_case		(    self     ):







   """simple docstring"""
   return NystromformerConfig(
       vocab_size=self.vocab_size			,  hidden_size=self.hidden_size			,  num_hidden_layers=self.num_hidden_layers			,  num_attention_heads=self.num_attention_heads			,  intermediate_size=self.intermediate_size			,  hidden_act=self.hidden_act			,  hidden_dropout_prob=self.hidden_dropout_prob			,  attention_probs_dropout_prob=self.attention_probs_dropout_prob			,  max_position_embeddings=self.max_position_embeddings			,  type_vocab_size=self.type_vocab_size			,  is_decoder=UpperCamelCase			,  initializer_range=self.initializer_range			,  )






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  NystromformerModel(config=UpperCamelCase     )
   model.to(UpperCamelCase     )
   model.eval()
   lowerCamelCase_      =  model(UpperCamelCase			,  attention_mask=UpperCamelCase			,  token_type_ids=UpperCamelCase     )
   lowerCamelCase_      =  model(UpperCamelCase			,  token_type_ids=UpperCamelCase     )
   lowerCamelCase_      =  model(UpperCamelCase     )
   self.parent.assertEqual(result.last_hidden_state.shape			,  (self.batch_size, self.seq_length, self.hidden_size)     )






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  NystromformerForMaskedLM(config=UpperCamelCase     )
   model.to(UpperCamelCase     )
   model.eval()
   lowerCamelCase_      =  model(UpperCamelCase			,  attention_mask=UpperCamelCase			,  token_type_ids=UpperCamelCase			,  labels=UpperCamelCase     )
   self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.seq_length, self.vocab_size)     )






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  NystromformerForQuestionAnswering(config=UpperCamelCase     )
   model.to(UpperCamelCase     )
   model.eval()
   lowerCamelCase_      =  model(
       UpperCamelCase			,  attention_mask=UpperCamelCase			,  token_type_ids=UpperCamelCase			,  start_positions=UpperCamelCase			,  end_positions=UpperCamelCase			,  )
   self.parent.assertEqual(result.start_logits.shape			,  (self.batch_size, self.seq_length)     )
   self.parent.assertEqual(result.end_logits.shape			,  (self.batch_size, self.seq_length)     )






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  self.num_labels
   lowerCamelCase_      =  NystromformerForSequenceClassification(UpperCamelCase     )
   model.to(UpperCamelCase     )
   model.eval()
   lowerCamelCase_      =  model(UpperCamelCase			,  attention_mask=UpperCamelCase			,  token_type_ids=UpperCamelCase			,  labels=UpperCamelCase     )
   self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.num_labels)     )






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  self.num_labels
   lowerCamelCase_      =  NystromformerForTokenClassification(config=UpperCamelCase     )
   model.to(UpperCamelCase     )
   model.eval()
   lowerCamelCase_      =  model(UpperCamelCase			,  attention_mask=UpperCamelCase			,  token_type_ids=UpperCamelCase			,  labels=UpperCamelCase     )
   self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.seq_length, self.num_labels)     )






  def   snake_case		(    self			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase			,  UpperCamelCase     ):







   """simple docstring"""
   lowerCamelCase_      =  self.num_choices
   lowerCamelCase_      =  NystromformerForMultipleChoice(config=UpperCamelCase     )
   model.to(UpperCamelCase     )
   model.eval()
   lowerCamelCase_      =  input_ids.unsqueeze(1     ).expand(-1			,  self.num_choices			,  -1     ).contiguous()
   lowerCamelCase_      =  token_type_ids.unsqueeze(1     ).expand(-1			,  self.num_choices			,  -1     ).contiguous()
   lowerCamelCase_      =  input_mask.unsqueeze(1     ).expand(-1			,  self.num_choices			,  -1     ).contiguous()
   lowerCamelCase_      =  model(
       UpperCamelCase			,  attention_mask=UpperCamelCase			,  token_type_ids=UpperCamelCase			,  labels=UpperCamelCase			,  )
   self.parent.assertEqual(result.logits.shape			,  (self.batch_size, self.num_choices)     )







  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.prepare_config_and_inputs()
   (
       (
       lowerCamelCase_
   ) ,(
       lowerCamelCase_
   ) ,(
       lowerCamelCase_
   ) ,(
       lowerCamelCase_
   ) ,(
       lowerCamelCase_
   ) ,(
       lowerCamelCase_
   ) ,(
       lowerCamelCase_
   ) ,
   )      =  config_and_inputs
   lowerCamelCase_      =  {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
   return config, inputs_dict





@require_torch
class      snake_case    (    lowercase			,						lowercase			,						unittest.TestCase			):





  """simple docstring"""




  _lowerCamelCase		    =  (
      (
          NystromformerModel,
          NystromformerForMaskedLM,
          NystromformerForMultipleChoice,
          NystromformerForQuestionAnswering,
          NystromformerForSequenceClassification,
          NystromformerForTokenClassification,
      )
      if is_torch_available()
      else ()
  )
  _lowerCamelCase		    =  (
      {
          "feature-extraction": NystromformerModel,
          "fill-mask": NystromformerForMaskedLM,
          "question-answering": NystromformerForQuestionAnswering,
          "text-classification": NystromformerForSequenceClassification,
          "token-classification": NystromformerForTokenClassification,
          "zero-shot": NystromformerForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )
  _lowerCamelCase		    =  False
  _lowerCamelCase		    =  False






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  NystromformerModelTester(self     )
   lowerCamelCase_      =  ConfigTester(self			,  config_class=UpperCamelCase			,  hidden_size=37     )






  def   snake_case		(    self     ):







   """simple docstring"""
   self.config_tester.run_common_tests()






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*UpperCamelCase     )






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.model_tester.prepare_config_and_inputs()
   for type in ["absolute", "relative_key", "relative_key_query"]:
    lowerCamelCase_      =  type
    self.model_tester.create_and_check_model(*UpperCamelCase     )






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_masked_lm(*UpperCamelCase     )






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_multiple_choice(*UpperCamelCase     )






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_question_answering(*UpperCamelCase     )






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_sequence_classification(*UpperCamelCase     )






  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_token_classification(*UpperCamelCase     )







  @slow
  def   snake_case		(    self     ):







   """simple docstring"""
   for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
    lowerCamelCase_      =  NystromformerModel.from_pretrained(UpperCamelCase     )
    self.assertIsNotNone(UpperCamelCase     )





@require_torch
class      snake_case    (    unittest.TestCase			):





  """simple docstring"""




  @slow
  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  NystromformerModel.from_pretrained("uw-madison/nystromformer-512"     )
   lowerCamelCase_      =  torch.tensor([[0, 1, 2, 3, 4, 5]]     )

   with torch.no_grad():
    lowerCamelCase_      =  model(UpperCamelCase     )[0]

   lowerCamelCase_      =  torch.Size((1, 6, 768)     )
   self.assertEqual(output.shape			,  UpperCamelCase     )

   lowerCamelCase_      =  torch.tensor(
       [[[-0.4_532, -0.0_936, 0.5_137], [-0.2_676, 0.0_628, 0.6_186], [-0.3_629, -0.1_726, 0.4_716]]]     )

   self.assertTrue(torch.allclose(output[:, :3, :3]			,  UpperCamelCase			,  atol=1e-4     )     )







  @slow
  def   snake_case		(    self     ):







   """simple docstring"""
   lowerCamelCase_      =  "the [MASK] of Belgium is Brussels"

   lowerCamelCase_      =  AutoTokenizer.from_pretrained("uw-madison/nystromformer-512"     )
   lowerCamelCase_      =  NystromformerForMaskedLM.from_pretrained("uw-madison/nystromformer-512"     )

   lowerCamelCase_      =  tokenizer(UpperCamelCase			,  return_tensors="pt"     )

   with torch.no_grad():
    lowerCamelCase_      =  model(encoding.input_ids     ).logits

   lowerCamelCase_      =  token_logits[:, 2, :].argmax(-1     )[0]

   self.assertEqual(tokenizer.decode(UpperCamelCase     )			,  "capital"     )







'''simple docstring'''

from __future__ import annotations

from fractions import Fraction





def __snake_case					(      UpperCAmelCase_						:						int					,				UpperCAmelCase_						:						int		):
 return (
     num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
 )





def __snake_case					(      UpperCAmelCase_						:						int		):
 lowerCamelCase_      =  []
 lowerCamelCase_      =  11
 lowerCamelCase_      =  int("1" + "0" * digit_len		)
 for num in range(UpperCAmelCase_					,				UpperCAmelCase_		):
  while den <= 99:
   if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
    if is_digit_cancelling(UpperCAmelCase_					,				UpperCAmelCase_		):
     solutions.append(F'''{num}/{den}'''		)
   den += 1
  num += 1
  lowerCamelCase_      =  10
 return solutions





def __snake_case					(      UpperCAmelCase_						:						int = 2		):
 lowerCamelCase_      =  1.0
 for fraction in fraction_list(UpperCAmelCase_		):
  lowerCamelCase_      =  Fraction(UpperCAmelCase_		)
  result *= frac.denominator / frac.numerator
 return int(UpperCAmelCase_		)


if __name__ == "__main__":
     print(solution())



