



"""simple docstring"""

from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow


if is_tf_available():
	import numpy as np
	import tensorflow as tf

	from transformers import TFXLMRobertaModel




@require_tf
@require_sentencepiece
@require_tokenizers
class SCREAMING_SNAKE_CASE__					(		unittest.TestCase      ):



						@slow
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		int									=       TFXLMRobertaModel.from_pretrained("""jplu/tf-xlm-roberta-base"""							)

													__a		:		int									=       {
													    """input_ids""": tf.convert_to_tensor([[0, 2646, 10269, 83, 99942, 2]]						,     dtype=tf.intaa							),  # "My dog is cute"
													    """attention_mask""": tf.convert_to_tensor([[1, 1, 1, 1, 1, 1]]						,     dtype=tf.intaa							),
													}

													__a		:		str									=       model(_lowercase							)["""last_hidden_state"""]
													__a		:		Tuple									=       tf.TensorShape((1, 6, 768)							)
													self.assertEqual(output.shape						,     _lowercase							)
													# compare the actual values for a slice.
													__a		:		Union[str, Any]									=       tf.convert_to_tensor(
													    [
													        [
													            [0.068_1762, 0.1089_4451, 0.0677_2504],
													            [-0.0642_3668, 0.0236_6615, 0.0432_9344],
													            [-0.0605_7295, 0.0997_4135, -0.0007_0584],
													        ]
													    ]						,     dtype=tf.floataa						,     )

													self.assertTrue(np.allclose(output[:, :3, :3].numpy()						,     expected_slice.numpy()						,     atol=1e-4							)							)






"""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.
lowercase__			   =  {"LayoutLMv2Config", "LayoutLMv3Config"}




@is_pipeline_test
class SCREAMING_SNAKE_CASE__					(		unittest.TestCase      ):
						_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     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		int									=       pipeline(
													    task="""text-classification"""						,     model="""hf-internal-testing/tiny-random-distilbert"""						,     framework="""pt"""							)

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

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

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

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

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

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

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

													__a		:		Union[str, Any]									=       text_classifier(["""This is great !""", """Something else"""]						,     return_all_scores=_lowercase							)
													self.assertEqual(
													    nested_simplify(_lowercase							)						,     [
													        {"""label""": """LABEL_0""", """score""": 0.504},
													        {"""label""": """LABEL_0""", """score""": 0.504},
													    ]						,     )



						@require_torch
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													import torch

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

													__a		:		Optional[int]									=       text_classifier("""This is great !"""							)
													self.assertEqual(nested_simplify(_lowercase							)						,     [{"""label""": """LABEL_0""", """score""": 0.504}]							)



						@require_tf
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		List[Any]									=       pipeline(
													    task="""text-classification"""						,     model="""hf-internal-testing/tiny-random-distilbert"""						,     framework="""tf"""							)

													__a		:		List[str]									=       text_classifier("""This is great !"""							)
													self.assertEqual(nested_simplify(_lowercase							)						,     [{"""label""": """LABEL_0""", """score""": 0.504}]							)



						@slow
						@require_torch
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Tuple									=       pipeline("""text-classification"""							)

													__a		:		Tuple									=       text_classifier("""This is great !"""							)
													self.assertEqual(nested_simplify(_lowercase							)						,     [{"""label""": """POSITIVE""", """score""": 1.0}]							)
													__a		:		Optional[int]									=       text_classifier("""This is bad !"""							)
													self.assertEqual(nested_simplify(_lowercase							)						,     [{"""label""": """NEGATIVE""", """score""": 1.0}]							)
													__a		:		Union[str, Any]									=       text_classifier("""Birds are a type of animal"""							)
													self.assertEqual(nested_simplify(_lowercase							)						,     [{"""label""": """POSITIVE""", """score""": 0.988}]							)



						@slow
						@require_tf
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		List[str]									=       pipeline("""text-classification"""						,     framework="""tf"""							)

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



						def     lowerCAmelCase__(self						,     _lowercase						,     _lowercase						,     _lowercase							):





													'''simple docstring'''

													__a		:		Dict									=       TextClassificationPipeline(model=_lowercase						,     tokenizer=_lowercase							)
													return text_classifier, ["HuggingFace is in", "This is another test"]





						def     lowerCAmelCase__(self						,     _lowercase						,     _lowercase							):





													'''simple docstring'''

													__a		:		List[str]									=       text_classifier.model
													# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
													__a		:		Union[str, Any]									=       """HuggingFace is in"""
													__a		:		List[str]									=       text_classifier(_lowercase							)

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

													__a		:		Optional[int]									=       ["""HuggingFace is in """, """Paris is in France"""]
													__a		:		Dict									=       text_classifier(_lowercase							)
													self.assertEqual(
													    nested_simplify(_lowercase							)						,     [{"""label""": ANY(_lowercase							), """score""": ANY(_lowercase							)}, {"""label""": ANY(_lowercase							), """score""": ANY(_lowercase							)}]						,     )
													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
													__a		:		Dict									=       text_classifier(_lowercase						,     top_k=_lowercase							)
													__a		:		Dict									=       len(model.config.idalabel.values()							)
													self.assertEqual(
													    nested_simplify(_lowercase							)						,     [[{"""label""": ANY(_lowercase							), """score""": ANY(_lowercase							)}] * N, [{"""label""": ANY(_lowercase							), """score""": ANY(_lowercase							)}] * N]						,     )

													__a		:		Dict									=       {"""text""": """HuggingFace is in """, """text_pair""": """Paris is in France"""}
													__a		:		Any									=       text_classifier(_lowercase							)
													self.assertEqual(
													    nested_simplify(_lowercase							)						,     {"""label""": ANY(_lowercase							), """score""": ANY(_lowercase							)}						,     )
													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.
													__a		:		Dict									=       [["""HuggingFace is in """, """Paris is in France"""]]
													with self.assertRaises(_lowercase							):
																				text_classifier(_lowercase							)

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

