
def 				a						(							snake_case__:					int						,   snake_case__:					int					):


				'''simple docstring'''
				return 1 if input_a == input_a else 0




def 				a						(							):


				'''simple docstring'''
				assert xnor_gate(0						,   0					) == 1
				assert xnor_gate(0						,   1					) == 0
				assert xnor_gate(1						,   0					) == 0
				assert xnor_gate(1						,   1					) == 1


if __name__ == "__main__":
						print(xnor_gate(0, 0))
						print(xnor_gate(0, 1))
						print(xnor_gate(1, 0))
						print(xnor_gate(1, 1))





import unittest

from transformers import SqueezeBertConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, 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 (
		    SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    SqueezeBertForMaskedLM,
		    SqueezeBertForMultipleChoice,
		    SqueezeBertForQuestionAnswering,
		    SqueezeBertForSequenceClassification,
		    SqueezeBertForTokenClassification,
		    SqueezeBertModel,
		)






class 		a__						(					A__					):

					def __init__(    self      :       Tuple,_A      :       Optional[int],_A      :       Any=13,_A      :       List[str]=7,_A      :       int=True,_A      :       Dict=True,_A      :       Dict=False,_A      :       List[Any]=True,_A      :       Any=99,_A      :       Optional[int]=32,_A      :       Any=5,_A      :       List[Any]=4,_A      :       Dict=64,_A      :       Optional[Any]="gelu",_A      :       Tuple=0.1,_A      :       Any=0.1,_A      :       List[Any]=512,_A      :       Dict=16,_A      :       Optional[Any]=2,_A      :       Union[str, Any]=0.02,_A      :       List[str]=3,_A      :       Optional[Any]=4,_A      :       Union[str, Any]=None,_A      :       Tuple=2,_A      :       List[str]=2,_A      :       str=2,_A      :       Dict=2,_A      :       Optional[Any]=4,_A      :       Union[str, Any]=1,):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    parent
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    batch_size
							SCREAMING_SNAKE_CASE_  :		Dict				      =    seq_length
							SCREAMING_SNAKE_CASE_  :		Dict				      =    is_training
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    use_input_mask
							SCREAMING_SNAKE_CASE_  :		int				      =    use_token_type_ids
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    use_labels
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    vocab_size
							SCREAMING_SNAKE_CASE_  :		Any				      =    hidden_size
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    num_hidden_layers
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    num_attention_heads
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    intermediate_size
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    hidden_act
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    hidden_dropout_prob
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    attention_probs_dropout_prob
							SCREAMING_SNAKE_CASE_  :		str				      =    max_position_embeddings
							SCREAMING_SNAKE_CASE_  :		str				      =    type_vocab_size
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    type_sequence_label_size
							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    initializer_range
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    num_labels
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    num_choices
							SCREAMING_SNAKE_CASE_  :		Dict				      =    scope
							SCREAMING_SNAKE_CASE_  :		int				      =    q_groups
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    k_groups
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    v_groups
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    post_attention_groups
							SCREAMING_SNAKE_CASE_  :		int				      =    intermediate_groups
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    output_groups

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







							"""simple docstring"""






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

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

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

							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    self.get_config()

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

					def 				__UpperCamelCase   (    self      :       str    ):







							"""simple docstring"""






							return SqueezeBertConfig(
							    embedding_size=self.hidden_size,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,attention_probs_dropout_prob=self.hidden_dropout_prob,attention_dropout=self.attention_probs_dropout_prob,max_position_embeddings=self.max_position_embeddings,initializer_range=self.initializer_range,q_groups=self.q_groups,k_groups=self.k_groups,v_groups=self.v_groups,post_attention_groups=self.post_attention_groups,intermediate_groups=self.intermediate_groups,output_groups=self.output_groups,)

					def 				__UpperCamelCase   (    self      :       Tuple,_A      :       Union[str, Any],_A      :       Union[str, Any],_A      :       int,_A      :       Optional[int],_A      :       Union[str, Any],_A      :       Any    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    SqueezeBertModel(config=_A    )
							model.to(_A    )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Any				      =    model(_A,_A    )
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    model(_A    )
							self.parent.assertEqual(result.last_hidden_state.shape,(self.batch_size, self.seq_length, self.hidden_size)    )

					def 				__UpperCamelCase   (    self      :       Dict,_A      :       Any,_A      :       Tuple,_A      :       str,_A      :       Any,_A      :       Union[str, Any],_A      :       Any    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    SqueezeBertForMaskedLM(config=_A    )
							model.to(_A    )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    model(_A,attention_mask=_A,labels=_A    )
							self.parent.assertEqual(result.logits.shape,(self.batch_size, self.seq_length, self.vocab_size)    )

					def 				__UpperCamelCase   (    self      :       Optional[int],_A      :       Union[str, Any],_A      :       Union[str, Any],_A      :       Any,_A      :       Tuple,_A      :       int,_A      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    SqueezeBertForQuestionAnswering(config=_A    )
							model.to(_A    )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Dict				      =    model(
							    _A,attention_mask=_A,start_positions=_A,end_positions=_A    )
							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 				__UpperCamelCase   (    self      :       List[Any],_A      :       List[str],_A      :       Tuple,_A      :       List[Any],_A      :       List[str],_A      :       List[str],_A      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int				      =    self.num_labels
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    SqueezeBertForSequenceClassification(_A    )
							model.to(_A    )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Dict				      =    model(_A,attention_mask=_A,labels=_A    )
							self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_labels)    )

					def 				__UpperCamelCase   (    self      :       str,_A      :       Optional[int],_A      :       str,_A      :       List[Any],_A      :       List[str],_A      :       str,_A      :       Dict    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    self.num_labels
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    SqueezeBertForTokenClassification(config=_A    )
							model.to(_A    )
							model.eval()

							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    model(_A,attention_mask=_A,labels=_A    )
							self.parent.assertEqual(result.logits.shape,(self.batch_size, self.seq_length, self.num_labels)    )

					def 				__UpperCamelCase   (    self      :       List[Any],_A      :       Tuple,_A      :       str,_A      :       Optional[Any],_A      :       int,_A      :       str,_A      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    self.num_choices
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    SqueezeBertForMultipleChoice(config=_A    )
							model.to(_A    )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Dict				      =    input_ids.unsqueeze(1    ).expand(-1,self.num_choices,-1    ).contiguous()
							SCREAMING_SNAKE_CASE_  :		str				      =    input_mask.unsqueeze(1    ).expand(-1,self.num_choices,-1    ).contiguous()
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    model(
							    _A,attention_mask=_A,labels=_A,)
							self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_choices)    )






					def 				__UpperCamelCase   (    self      :       Optional[int]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    self.prepare_config_and_inputs()
							((SCREAMING_SNAKE_CASE_)      ,    (SCREAMING_SNAKE_CASE_)      ,    (SCREAMING_SNAKE_CASE_)      ,    (SCREAMING_SNAKE_CASE_)      ,    (SCREAMING_SNAKE_CASE_)      ,    (SCREAMING_SNAKE_CASE_))  :		Dict				      =    config_and_inputs
							SCREAMING_SNAKE_CASE_  :		Dict				      =    {"input_ids": input_ids, "attention_mask": input_mask}
							return config, inputs_dict







@require_torch
class 		a__						(					A__    ,		A__    ,		unittest.TestCase					):
					A	       =							(
					    (
					        SqueezeBertModel,
					        SqueezeBertForMaskedLM,
					        SqueezeBertForMultipleChoice,
					        SqueezeBertForQuestionAnswering,
					        SqueezeBertForSequenceClassification,
					        SqueezeBertForTokenClassification,
					    )
					    if is_torch_available()
					    else None
					)
					A	       =							(
					    {
					        'feature-extraction': SqueezeBertModel,
					        'fill-mask': SqueezeBertForMaskedLM,
					        'question-answering': SqueezeBertForQuestionAnswering,
					        'text-classification': SqueezeBertForSequenceClassification,
					        'token-classification': SqueezeBertForTokenClassification,
					        'zero-shot': SqueezeBertForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					A	       =							False
					A	       =							True
					A	       =							False

					def 				__UpperCamelCase   (    self      :       int    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int				      =    SqueezeBertModelTester(self    )
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    ConfigTester(self,config_class=_A,dim=37    )

					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							self.config_tester.run_common_tests()

					def 				__UpperCamelCase   (    self      :       Tuple    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_squeezebert_model(*_A    )

					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_squeezebert_for_masked_lm(*_A    )

					def 				__UpperCamelCase   (    self      :       int    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_squeezebert_for_question_answering(*_A    )

					def 				__UpperCamelCase   (    self      :       Dict    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_squeezebert_for_sequence_classification(*_A    )

					def 				__UpperCamelCase   (    self      :       Tuple    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_squeezebert_for_token_classification(*_A    )

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







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_squeezebert_for_multiple_choice(*_A    )






					@slow
					def 				__UpperCamelCase   (    self      :       Any    ):







							"""simple docstring"""






							for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE_  :		Tuple				      =    SqueezeBertModel.from_pretrained(_A    )
									self.assertIsNotNone(_A    )







@require_sentencepiece
@require_tokenizers
@require_torch
class 		a__						(					unittest.TestCase					):

					@slow
					def 				__UpperCamelCase   (    self      :       int    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		str				      =    SqueezeBertForSequenceClassification.from_pretrained("squeezebert/squeezebert-mnli"    )

							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    torch.tensor([[1, 2_9414, 232, 328, 740, 1140, 1_2695, 69, 13, 1588, 2]]    )
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    model(_A    )[0]
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    torch.Size((1, 3)    )
							self.assertEqual(output.shape,_A    )
							SCREAMING_SNAKE_CASE_  :		int				      =    torch.tensor([[0.6401, -0.0349, -0.6041]]    )
							self.assertTrue(torch.allclose(_A,_A,atol=1E-4    )    )
