




import unittest

from transformers import 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, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch

						from transformers import (
						    RemBertConfig,
						    RemBertForCausalLM,
						    RemBertForMaskedLM,
						    RemBertForMultipleChoice,
						    RemBertForQuestionAnswering,
						    RemBertForSequenceClassification,
						    RemBertForTokenClassification,
						    RemBertModel,
						)
						from transformers.models.rembert.modeling_rembert import REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST



class       lowercase_		:



						def __init__( self  :      List[Any]				,       snake_case__  :      Tuple				,       snake_case__  :      str=13				,       snake_case__  :      List[str]=7				,       snake_case__  :      Union[str, Any]=True				,       snake_case__  :      Tuple=True				,       snake_case__  :      Any=True				,       snake_case__  :      Union[str, Any]=True				,       snake_case__  :      Union[str, Any]=99				,       snake_case__  :      List[str]=32				,       snake_case__  :      Any=18				,       snake_case__  :      Dict=43				,       snake_case__  :      int=5				,       snake_case__  :      Optional[Any]=4				,       snake_case__  :      Any=37				,       snake_case__  :      List[str]="gelu"				,       snake_case__  :      Dict=0.1				,       snake_case__  :      int=0.1				,       snake_case__  :      str=5_12				,       snake_case__  :      Optional[int]=16				,       snake_case__  :      Union[str, Any]=2				,       snake_case__  :      Optional[int]=0.02				,       snake_case__  :      List[Any]=3				,       snake_case__  :      List[str]=4				,       snake_case__  :      List[str]=None				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       parent
								SCREAMING_SNAKE_CASE_							=       batch_size
								SCREAMING_SNAKE_CASE_							=       seq_length
								SCREAMING_SNAKE_CASE_							=       is_training
								SCREAMING_SNAKE_CASE_							=       use_input_mask
								SCREAMING_SNAKE_CASE_							=       use_token_type_ids
								SCREAMING_SNAKE_CASE_							=       use_labels
								SCREAMING_SNAKE_CASE_							=       vocab_size
								SCREAMING_SNAKE_CASE_							=       hidden_size
								SCREAMING_SNAKE_CASE_							=       input_embedding_size
								SCREAMING_SNAKE_CASE_							=       output_embedding_size
								SCREAMING_SNAKE_CASE_							=       num_hidden_layers
								SCREAMING_SNAKE_CASE_							=       num_attention_heads
								SCREAMING_SNAKE_CASE_							=       intermediate_size
								SCREAMING_SNAKE_CASE_							=       hidden_act
								SCREAMING_SNAKE_CASE_							=       hidden_dropout_prob
								SCREAMING_SNAKE_CASE_							=       attention_probs_dropout_prob
								SCREAMING_SNAKE_CASE_							=       max_position_embeddings
								SCREAMING_SNAKE_CASE_							=       type_vocab_size
								SCREAMING_SNAKE_CASE_							=       type_sequence_label_size
								SCREAMING_SNAKE_CASE_							=       initializer_range
								SCREAMING_SNAKE_CASE_							=       num_labels
								SCREAMING_SNAKE_CASE_							=       num_choices
								SCREAMING_SNAKE_CASE_							=       scope



						def   __a				( self  :      Dict     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       ids_tensor([self.batch_size, self.seq_length]				,       self.vocab_size     )

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

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

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

								SCREAMING_SNAKE_CASE_							=       RemBertConfig(
								    vocab_size=self.vocab_size				,       hidden_size=self.hidden_size				,       input_embedding_size=self.input_embedding_size				,       output_embedding_size=self.output_embedding_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=snake_case__				,       initializer_range=self.initializer_range				,       )

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



						def   __a				( self  :      int     ):

								"""simple docstring"""

								(
								    (
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							
								)							=       self.prepare_config_and_inputs()

								SCREAMING_SNAKE_CASE_							=       True
								SCREAMING_SNAKE_CASE_							=       floats_tensor([self.batch_size, self.seq_length, self.hidden_size]     )
								SCREAMING_SNAKE_CASE_							=       ids_tensor([self.batch_size, self.seq_length]				,       vocab_size=2     )

								return (
								    config,
								    input_ids,
								    token_type_ids,
								    input_mask,
								    sequence_labels,
								    token_labels,
								    choice_labels,
								    encoder_hidden_states,
								    encoder_attention_mask,
								)



						def   __a				( self  :      Dict				,       snake_case__  :      List[Any]				,       snake_case__  :      Any				,       snake_case__  :      int				,       snake_case__  :      Any				,       snake_case__  :      int				,       snake_case__  :      Any				,       snake_case__  :      Tuple     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       RemBertModel(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__     )
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       token_type_ids=snake_case__     )
								SCREAMING_SNAKE_CASE_							=       model(snake_case__     )
								self.parent.assertEqual(result.last_hidden_state.shape				,       (self.batch_size, self.seq_length, self.hidden_size)     )



						def   __a				( self  :      int				,       snake_case__  :      Optional[int]				,       snake_case__  :      Dict				,       snake_case__  :      List[Any]				,       snake_case__  :      Dict				,       snake_case__  :      List[Any]				,       snake_case__  :      List[Any]				,       snake_case__  :      Optional[int]				,       snake_case__  :      str				,       snake_case__  :      List[str]				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       True
								SCREAMING_SNAKE_CASE_							=       RemBertModel(snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(
								    snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       encoder_hidden_states=snake_case__				,       encoder_attention_mask=snake_case__				,       )
								SCREAMING_SNAKE_CASE_							=       model(
								    snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       encoder_hidden_states=snake_case__				,       )
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__     )
								self.parent.assertEqual(result.last_hidden_state.shape				,       (self.batch_size, self.seq_length, self.hidden_size)     )



						def   __a				( self  :      str				,       snake_case__  :      Dict				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      Optional[Any]				,       snake_case__  :      str				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      Dict				,       snake_case__  :      List[str]				,       snake_case__  :      Dict				,       snake_case__  :      str				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       RemBertForCausalLM(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       labels=snake_case__     )
								self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.seq_length, self.vocab_size)     )



						def   __a				( self  :      Tuple				,       snake_case__  :      str				,       snake_case__  :      str				,       snake_case__  :      Optional[int]				,       snake_case__  :      Optional[Any]				,       snake_case__  :      List[str]				,       snake_case__  :      List[str]				,       snake_case__  :      List[Any]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       RemBertForMaskedLM(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       labels=snake_case__     )
								self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.seq_length, self.vocab_size)     )



						def   __a				( self  :      Optional[int]				,       snake_case__  :      Optional[int]				,       snake_case__  :      Optional[Any]				,       snake_case__  :      Optional[Any]				,       snake_case__  :      Optional[Any]				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      int				,       snake_case__  :      int				,       snake_case__  :      Optional[int]				,       snake_case__  :      Union[str, Any]				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       True
								SCREAMING_SNAKE_CASE_							=       True
								SCREAMING_SNAKE_CASE_							=       RemBertForCausalLM(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()

								# first forward pass
								SCREAMING_SNAKE_CASE_							=       model(
								    snake_case__				,       attention_mask=snake_case__				,       encoder_hidden_states=snake_case__				,       encoder_attention_mask=snake_case__				,       use_cache=snake_case__				,       )
								SCREAMING_SNAKE_CASE_							=       outputs.past_key_values

								# create hypothetical multiple next token and extent to next_input_ids
								SCREAMING_SNAKE_CASE_							=       ids_tensor((self.batch_size, 3)				,       config.vocab_size     )
								SCREAMING_SNAKE_CASE_							=       ids_tensor((self.batch_size, 3)				,       vocab_size=2     )

								# append to next input_ids and
								SCREAMING_SNAKE_CASE_							=       torch.cat([input_ids, next_tokens]				,       dim=-1     )
								SCREAMING_SNAKE_CASE_							=       torch.cat([input_mask, next_mask]				,       dim=-1     )

								SCREAMING_SNAKE_CASE_							=       model(
								    snake_case__				,       attention_mask=snake_case__				,       encoder_hidden_states=snake_case__				,       encoder_attention_mask=snake_case__				,       output_hidden_states=snake_case__				,       )['hidden_states'][0]
								SCREAMING_SNAKE_CASE_							=       model(
								    snake_case__				,       attention_mask=snake_case__				,       encoder_hidden_states=snake_case__				,       encoder_attention_mask=snake_case__				,       past_key_values=snake_case__				,       output_hidden_states=snake_case__				,       )['hidden_states'][0]

								# select random slice
								SCREAMING_SNAKE_CASE_							=       ids_tensor((1,)				,       output_from_past.shape[-1]     ).item()
								SCREAMING_SNAKE_CASE_							=       output_from_no_past[:, -3:, random_slice_idx].detach()
								SCREAMING_SNAKE_CASE_							=       output_from_past[:, :, random_slice_idx].detach()

								self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]     )

								# test that outputs are equal for slice
								self.parent.assertTrue(torch.allclose(snake_case__				,       snake_case__				,       atol=1e-3     )     )



						def   __a				( self  :      str				,       snake_case__  :      Tuple				,       snake_case__  :      List[Any]				,       snake_case__  :      str				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      str				,       snake_case__  :      Dict				,       snake_case__  :      Tuple     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       RemBertForQuestionAnswering(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(
								    snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       start_positions=snake_case__				,       end_positions=snake_case__				,       )
								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   __a				( self  :      Tuple				,       snake_case__  :      Tuple				,       snake_case__  :      List[str]				,       snake_case__  :      Any				,       snake_case__  :      Dict				,       snake_case__  :      Optional[int]				,       snake_case__  :      str				,       snake_case__  :      Optional[int]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.num_labels
								SCREAMING_SNAKE_CASE_							=       RemBertForSequenceClassification(snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       labels=snake_case__     )
								self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_labels)     )



						def   __a				( self  :      Optional[Any]				,       snake_case__  :      List[str]				,       snake_case__  :      Optional[Any]				,       snake_case__  :      Dict				,       snake_case__  :      Optional[int]				,       snake_case__  :      Tuple				,       snake_case__  :      str				,       snake_case__  :      List[Any]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.num_labels
								SCREAMING_SNAKE_CASE_							=       RemBertForTokenClassification(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       labels=snake_case__     )
								self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.seq_length, self.num_labels)     )



						def   __a				( self  :      Tuple				,       snake_case__  :      str				,       snake_case__  :      Tuple				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      List[str]				,       snake_case__  :      List[Any]				,       snake_case__  :      Tuple				,       snake_case__  :      List[str]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.num_choices
								SCREAMING_SNAKE_CASE_							=       RemBertForMultipleChoice(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       input_ids.unsqueeze(1     ).expand(-1				,       self.num_choices				,       -1     ).contiguous()
								SCREAMING_SNAKE_CASE_							=       token_type_ids.unsqueeze(1     ).expand(-1				,       self.num_choices				,       -1     ).contiguous()
								SCREAMING_SNAKE_CASE_							=       input_mask.unsqueeze(1     ).expand(-1				,       self.num_choices				,       -1     ).contiguous()
								SCREAMING_SNAKE_CASE_							=       model(
								    snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       labels=snake_case__				,       )
								self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_choices)     )






						def   __a				( self  :      Tuple     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.prepare_config_and_inputs()
								(
								    (
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							
								)							=       config_and_inputs
								SCREAMING_SNAKE_CASE_							=       {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
								return config, inputs_dict



@require_torch
class       lowercase_		(SCREAMING_SNAKE_CASE__       ,  SCREAMING_SNAKE_CASE__       ,  unittest.TestCase   ):
						lowerCAmelCase__ 			=(
						    (
						        RemBertModel,
						        RemBertForMaskedLM,
						        RemBertForCausalLM,
						        RemBertForMultipleChoice,
						        RemBertForQuestionAnswering,
						        RemBertForSequenceClassification,
						        RemBertForTokenClassification,
						    )
						    if is_torch_available()
						    else ()
						)
						lowerCAmelCase__ 			=(RemBertForCausalLM,) if is_torch_available() else ()
						lowerCAmelCase__ 			=(
						    {
						        "feature-extraction": RemBertModel,
						        "fill-mask": RemBertForMaskedLM,
						        "question-answering": RemBertForQuestionAnswering,
						        "text-classification": RemBertForSequenceClassification,
						        "text-generation": RemBertForCausalLM,
						        "token-classification": RemBertForTokenClassification,
						        "zero-shot": RemBertForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)



						def   __a				( self  :      Optional[int]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       RemBertModelTester(self     )
								SCREAMING_SNAKE_CASE_							=       ConfigTester(self				,       config_class=snake_case__				,       hidden_size=37     )



						def   __a				( self  :      List[str]     ):

								"""simple docstring"""

								self.config_tester.run_common_tests()



						def   __a				( self  :      List[str]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case__     )



						def   __a				( self  :      str     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
										SCREAMING_SNAKE_CASE_							=       type
										self.model_tester.create_and_check_model(*snake_case__     )



						def   __a				( self  :      Dict     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*snake_case__     )



						def   __a				( self  :      Any     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_multiple_choice(*snake_case__     )



						def   __a				( self  :      List[Any]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs_for_decoder()
								self.model_tester.create_and_check_decoder_model_past_large_inputs(*snake_case__     )



						def   __a				( self  :      List[Any]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*snake_case__     )



						def   __a				( self  :      int     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*snake_case__     )



						def   __a				( self  :      List[str]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*snake_case__     )



						def   __a				( self  :      Union[str, Any]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs_for_decoder()
								self.model_tester.create_and_check_model_as_decoder(*snake_case__     )



						def   __a				( self  :      Optional[int]     ):

								"""simple docstring"""

								(
								    (
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							
								)							=       self.model_tester.prepare_config_and_inputs_for_decoder()

								SCREAMING_SNAKE_CASE_							=       None

								self.model_tester.create_and_check_model_as_decoder(
								    snake_case__				,       snake_case__				,       snake_case__				,       snake_case__				,       snake_case__				,       snake_case__				,       snake_case__				,       snake_case__				,       snake_case__				,       )






						@slow
						def   __a				( self  :      List[str]     ):

								"""simple docstring"""

								for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										SCREAMING_SNAKE_CASE_							=       RemBertModel.from_pretrained(snake_case__     )
										self.assertIsNotNone(snake_case__     )



@require_torch
class       lowercase_		(unittest.TestCase   ):



						@slow
						def   __a				( self  :      Any     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       RemBertModel.from_pretrained('google/rembert'     )
								SCREAMING_SNAKE_CASE_							=       torch.tensor([[3_12, 5_64_98, 3_13, 21_25, 3_13]]     )
								SCREAMING_SNAKE_CASE_							=       torch.tensor([[0, 0, 0, 1, 1]]     )
								with torch.no_grad():
										SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       token_type_ids=snake_case__				,       output_hidden_states=snake_case__     )

								SCREAMING_SNAKE_CASE_							=       11_52

								SCREAMING_SNAKE_CASE_							=       torch.Size((1, 5, hidden_size)     )
								self.assertEqual(output['last_hidden_state'].shape				,       snake_case__     )

								SCREAMING_SNAKE_CASE_							=       torch.tensor(
								    [
								        [
								            [0.07_54, -0.20_22, 0.19_04],
								            [-0.33_54, -0.36_92, -0.47_91],
								            [-0.23_14, -0.67_29, -0.07_49],
								            [-0.03_96, -0.31_05, -0.42_34],
								            [-0.15_71, -0.05_25, 0.53_53],
								        ]
								    ]     )

								# Running on the original tf implementation gives slightly different results here.
								# Not clear why this variations is present
								# TODO: Find reason for discrepancy
								# expected_original_implementation = [[
								#     [0.07630594074726105, -0.20146065950393677, 0.19107051193714142],
								#     [-0.3405614495277405, -0.36971670389175415, -0.4808273911476135],
								#     [-0.22587086260318756, -0.6656315922737122, -0.07844287157058716],
								#     [-0.04145475849509239, -0.3077218234539032, -0.42316967248916626],
								#     [-0.15887849032878876, -0.054529931396245956, 0.5356100797653198]
								# ]]

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





from __future__ import annotations


def 				_a       (				lowerCAmelCase						,	lowerCAmelCase   )->  int:
		SCREAMING_SNAKE_CASE_			,							SCREAMING_SNAKE_CASE_							=       0, len(lowerCAmelCase   ) - 1
		while start_ind <= end_ind:
				if array[start_ind] == search_item:
						return start_ind
				elif array[end_ind] == search_item:
						return end_ind
				else:
						start_ind += 1
						end_ind -= 1
    # returns -1 if search_item is not found in array
		return -1


if __name__ == "__main__":
						print(double_linear_search(list(range(1_0_0)), 4_0))