






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  UpperCamelCase_      (			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 							_UpperCamelCase			(       self					)       ->    Tuple:
								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(lowerCAmelCase__					)       ,			[{'label': 'LABEL_0', 'score': 0.504}]					)

								snake_case_				=							text_classifier('This is great !'       ,			top_k=2					)
								self.assertEqual(
								    nested_simplify(lowerCAmelCase__					)       ,			[{'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(lowerCAmelCase__					)       ,			[
								        [{'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(lowerCAmelCase__					)       ,			[{'label': 'LABEL_0', 'score': 0.504}]					)

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

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

								snake_case_				=							text_classifier(['This is great !', 'Something else']       ,			return_all_scores=lowerCAmelCase__					)
								self.assertEqual(
								    nested_simplify(lowerCAmelCase__					)       ,			[
								        [{'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=lowerCAmelCase__					)
								self.assertEqual(
								    nested_simplify(lowerCAmelCase__					)       ,			[
								        {'label': 'LABEL_0', 'score': 0.504},
								        {'label': 'LABEL_0', 'score': 0.504},
								    ]       ,			)




	@require_torch
	def 							_UpperCamelCase			(       self					)       ->    Dict:
								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(lowerCAmelCase__					)       ,			[{'label': 'LABEL_0', 'score': 0.504}]					)




	@require_tf
	def 							_UpperCamelCase			(       self					)       ->    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(lowerCAmelCase__					)       ,			[{'label': 'LABEL_0', 'score': 0.504}]					)




	@slow
	@require_torch
	def 							_UpperCamelCase			(       self					)       ->    str:
								snake_case_				=							pipeline('text-classification'					)

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




	@slow
	@require_tf
	def 							_UpperCamelCase			(       self					)       ->    Tuple:
								snake_case_				=							pipeline('text-classification'       ,			framework='tf'					)

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




	def 							_UpperCamelCase			(       self       ,			a       ,			a       ,			a					)       ->    List[Any]:
								snake_case_				=							TextClassificationPipeline(model=lowerCAmelCase__       ,			tokenizer=lowerCAmelCase__					)
								return text_classifier, ["HuggingFace is in", "This is another test"]






	def 							_UpperCamelCase			(       self       ,			a       ,			a					)       ->    List[str]:
								snake_case_				=							text_classifier.model
								# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
								snake_case_				=							"HuggingFace is in"
								snake_case_				=							text_classifier(lowerCAmelCase__					)

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

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

								snake_case_				=							{"text": "HuggingFace is in ", "text_pair": "Paris is in France"}
								snake_case_				=							text_classifier(lowerCAmelCase__					)
								self.assertEqual(
								    nested_simplify(lowerCAmelCase__					)       ,			{'label': ANY(lowerCAmelCase__					), 'score': ANY(lowerCAmelCase__					)}       ,			)
								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(lowerCAmelCase__					):
															text_classifier(lowerCAmelCase__					)

								# 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(lowerCAmelCase__					)       ,			[{'label': ANY(lowerCAmelCase__					), 'score': ANY(lowerCAmelCase__					)}]       ,			)
								self.assertTrue(outputs[0]['label'] in model.config.idalabel.values()					)












import numpy as np
def      _A       (		SCREAMING_SNAKE_CASE     :   np.array						):





  """simple docstring"""



  return 1 / (1 + np.exp(-vector						))


if __name__ == "__main__":
     import doctest

     doctest.testmod()






