
'''simple docstring'''
import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TextClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
__lowerCAmelCase												=	{'LayoutLMv2Config', 'LayoutLMv3Config'}


@is_pipeline_test
class       _lowerCAmelCase   (   unittest.TestCase				):







							'''simple docstring'''

							lowerCAmelCase_ 						=						MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
							lowerCAmelCase_ 						=						TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

							if model_mapping is not None:
														lowerCAmelCase_ 						=						{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
							if tf_model_mapping is not None:
														lowerCAmelCase_ 						=						{
														    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
														}

							@require_torch
							def 	lowercase							(self  )					->       int:
														_snake_case       =  pipeline(
														    task="""text-classification"""  ,  model="""hf-internal-testing/tiny-random-distilbert"""  ,  framework="""pt"""  )

														_snake_case       =  text_classifier("""This is great !"""  )
														self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": """LABEL_0""", """score""": 0.504}]  )

														_snake_case       =  text_classifier("""This is great !"""  ,  top_k=2  )
														self.assertEqual(
														    nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": """LABEL_0""", """score""": 0.504}, {"""label""": """LABEL_1""", """score""": 0.496}]  )

														_snake_case       =  text_classifier(["""This is great !""", """This is bad"""]  ,  top_k=2  )
														self.assertEqual(
														    nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [
														        [{"""label""": """LABEL_0""", """score""": 0.504}, {"""label""": """LABEL_1""", """score""": 0.496}],
														        [{"""label""": """LABEL_0""", """score""": 0.504}, {"""label""": """LABEL_1""", """score""": 0.496}],
														    ]  ,  )

														_snake_case       =  text_classifier("""This is great !"""  ,  top_k=1  )
														self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": """LABEL_0""", """score""": 0.504}]  )

														# Legacy behavior
														_snake_case       =  text_classifier("""This is great !"""  ,  return_all_scores=_SCREAMING_SNAKE_CASE  )
														self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": """LABEL_0""", """score""": 0.504}]  )

														_snake_case       =  text_classifier("""This is great !"""  ,  return_all_scores=_SCREAMING_SNAKE_CASE  )
														self.assertEqual(
														    nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [[{"""label""": """LABEL_0""", """score""": 0.504}, {"""label""": """LABEL_1""", """score""": 0.496}]]  )

														_snake_case       =  text_classifier(["""This is great !""", """Something else"""]  ,  return_all_scores=_SCREAMING_SNAKE_CASE  )
														self.assertEqual(
														    nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [
														        [{"""label""": """LABEL_0""", """score""": 0.504}, {"""label""": """LABEL_1""", """score""": 0.496}],
														        [{"""label""": """LABEL_0""", """score""": 0.504}, {"""label""": """LABEL_1""", """score""": 0.496}],
														    ]  ,  )

														_snake_case       =  text_classifier(["""This is great !""", """Something else"""]  ,  return_all_scores=_SCREAMING_SNAKE_CASE  )
														self.assertEqual(
														    nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [
														        {"""label""": """LABEL_0""", """score""": 0.504},
														        {"""label""": """LABEL_0""", """score""": 0.504},
														    ]  ,  )

							@require_torch
							def 	lowercase							(self  )					->       Optional[int]:
														import torch

														_snake_case       =  pipeline(
														    task="""text-classification"""  ,  model="""hf-internal-testing/tiny-random-distilbert"""  ,  framework="""pt"""  ,  device=torch.device("""cpu"""  )  ,  )

														_snake_case       =  text_classifier("""This is great !"""  )
														self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": """LABEL_0""", """score""": 0.504}]  )

							@require_tf
							def 	lowercase							(self  )					->       List[Any]:
														_snake_case       =  pipeline(
														    task="""text-classification"""  ,  model="""hf-internal-testing/tiny-random-distilbert"""  ,  framework="""tf"""  )

														_snake_case       =  text_classifier("""This is great !"""  )
														self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": """LABEL_0""", """score""": 0.504}]  )

							@slow
							@require_torch
							def 	lowercase							(self  )					->       Dict:
														_snake_case       =  pipeline("""text-classification"""  )

														_snake_case       =  text_classifier("""This is great !"""  )
														self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": """POSITIVE""", """score""": 1.0}]  )
														_snake_case       =  text_classifier("""This is bad !"""  )
														self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": """NEGATIVE""", """score""": 1.0}]  )
														_snake_case       =  text_classifier("""Birds are a type of animal"""  )
														self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": """POSITIVE""", """score""": 0.988}]  )

							@slow
							@require_tf
							def 	lowercase							(self  )					->       List[str]:
														_snake_case       =  pipeline("""text-classification"""  ,  framework="""tf"""  )

														_snake_case       =  text_classifier("""This is great !"""  )
														self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": """POSITIVE""", """score""": 1.0}]  )
														_snake_case       =  text_classifier("""This is bad !"""  )
														self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": """NEGATIVE""", """score""": 1.0}]  )
														_snake_case       =  text_classifier("""Birds are a type of animal"""  )
														self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": """POSITIVE""", """score""": 0.988}]  )

							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       Union[str, Any]:
														_snake_case       =  TextClassificationPipeline(model=_SCREAMING_SNAKE_CASE  ,  tokenizer=_SCREAMING_SNAKE_CASE  )
														return text_classifier, ["HuggingFace is in", "This is another test"]





							def 	lowercase							(self  ,  UpperCAmelCase  ,  UpperCAmelCase  )					->       List[Any]:
														_snake_case       =  text_classifier.model
														# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
														_snake_case       =  "HuggingFace is in"
														_snake_case       =  text_classifier(_SCREAMING_SNAKE_CASE  )

														self.assertEqual(nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": ANY(_SCREAMING_SNAKE_CASE  ), """score""": ANY(_SCREAMING_SNAKE_CASE  )}]  )
														self.assertTrue(outputs[0]["""label"""] in model.config.idalabel.values()  )

														_snake_case       =  ["HuggingFace is in ", "Paris is in France"]
														_snake_case       =  text_classifier(_SCREAMING_SNAKE_CASE  )
														self.assertEqual(
														    nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": ANY(_SCREAMING_SNAKE_CASE  ), """score""": ANY(_SCREAMING_SNAKE_CASE  )}, {"""label""": ANY(_SCREAMING_SNAKE_CASE  ), """score""": ANY(_SCREAMING_SNAKE_CASE  )}]  ,  )
														self.assertTrue(outputs[0]["""label"""] in model.config.idalabel.values()  )
														self.assertTrue(outputs[1]["""label"""] in model.config.idalabel.values()  )

														# Forcing to get all results with `top_k=None`
														# This is NOT the legacy format
														_snake_case       =  text_classifier(_SCREAMING_SNAKE_CASE  ,  top_k=_SCREAMING_SNAKE_CASE  )
														_snake_case       =  len(model.config.idalabel.values()  )
														self.assertEqual(
														    nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [[{"""label""": ANY(_SCREAMING_SNAKE_CASE  ), """score""": ANY(_SCREAMING_SNAKE_CASE  )}] * N, [{"""label""": ANY(_SCREAMING_SNAKE_CASE  ), """score""": ANY(_SCREAMING_SNAKE_CASE  )}] * N]  ,  )

														_snake_case       =  {"text": "HuggingFace is in ", "text_pair": "Paris is in France"}
														_snake_case       =  text_classifier(_SCREAMING_SNAKE_CASE  )
														self.assertEqual(
														    nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  {"""label""": ANY(_SCREAMING_SNAKE_CASE  ), """score""": ANY(_SCREAMING_SNAKE_CASE  )}  ,  )
														self.assertTrue(outputs["""label"""] in model.config.idalabel.values()  )

														# This might be used a text pair, but tokenizer + pipe interaction
														# makes it hard to understand that it's not using the pair properly
														# https://github.com/huggingface/transformers/issues/17305
														# We disabled this usage instead as it was outputting wrong outputs.
														_snake_case       =  [["HuggingFace is in ", "Paris is in France"]]
														with self.assertRaises(_SCREAMING_SNAKE_CASE  ):
																					text_classifier(_SCREAMING_SNAKE_CASE  )

														# This used to be valid for doing text pairs
														# We're keeping it working because of backward compatibility
														_snake_case       =  text_classifier([[["""HuggingFace is in """, """Paris is in France"""]]]  )
														self.assertEqual(
														    nested_simplify(_SCREAMING_SNAKE_CASE  )  ,  [{"""label""": ANY(_SCREAMING_SNAKE_CASE  ), """score""": ANY(_SCREAMING_SNAKE_CASE  )}]  ,  )
														self.assertTrue(outputs[0]["""label"""] in model.config.idalabel.values()  )

'''simple docstring'''
import logging

from transformers.configuration_utils import PretrainedConfig


__lowerCAmelCase												=	logging.getLogger(__name__)


class       _lowerCAmelCase   (   __snake_case				):







							'''simple docstring'''

							lowerCAmelCase_ 						=						"masked_bert"

							def __init__(self  ,  UpperCAmelCase=30522  ,  UpperCAmelCase=768  ,  UpperCAmelCase=12  ,  UpperCAmelCase=12  ,  UpperCAmelCase=3072  ,  UpperCAmelCase="gelu"  ,  UpperCAmelCase=0.1  ,  UpperCAmelCase=0.1  ,  UpperCAmelCase=512  ,  UpperCAmelCase=2  ,  UpperCAmelCase=0.02  ,  UpperCAmelCase=1e-1_2  ,  UpperCAmelCase=0  ,  UpperCAmelCase="topK"  ,  UpperCAmelCase="constant"  ,  UpperCAmelCase=0.0  ,  **UpperCAmelCase  ,  )					->       int:
														super().__init__(pad_token_id=UpperCAmelCase  ,  **UpperCAmelCase  )

														_snake_case       =  vocab_size
														_snake_case       =  hidden_size
														_snake_case       =  num_hidden_layers
														_snake_case       =  num_attention_heads
														_snake_case       =  hidden_act
														_snake_case       =  intermediate_size
														_snake_case       =  hidden_dropout_prob
														_snake_case       =  attention_probs_dropout_prob
														_snake_case       =  max_position_embeddings
														_snake_case       =  type_vocab_size
														_snake_case       =  initializer_range
														_snake_case       =  layer_norm_eps
														_snake_case       =  pruning_method
														_snake_case       =  mask_init
														_snake_case       =  mask_scale