

import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    Pipeline,
    ZeroShotClassificationPipeline,
    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 					__lowerCAmelCase	(   unittest.TestCase				):
  _a		     =    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
  _a		     =    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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




  def     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					Dict:
        '''simple docstring'''






        _lowercase      			=ZeroShotClassificationPipeline(
            model=lowerCAmelCase				,  tokenizer=lowerCAmelCase				,  candidate_labels=['polics', 'health']   )
        return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]




  def     A__	(							self				,  lowerCAmelCase				,  lowerCAmelCase   )    ->					str:
        '''simple docstring'''






        _lowercase      			=classifier('Who are you voting for in 2020?'				,  candidate_labels='politics'   )
        self.assertEqual(lowerCAmelCase				,  {'sequence': ANY(lowerCAmelCase   ), 'labels': [ANY(lowerCAmelCase   )], 'scores': [ANY(lowerCAmelCase   )]}   )

        # No kwarg
        _lowercase      			=classifier('Who are you voting for in 2020?'				,  ['politics']   )
        self.assertEqual(lowerCAmelCase				,  {'sequence': ANY(lowerCAmelCase   ), 'labels': [ANY(lowerCAmelCase   )], 'scores': [ANY(lowerCAmelCase   )]}   )

        _lowercase      			=classifier('Who are you voting for in 2020?'				,  candidate_labels=['politics']   )
        self.assertEqual(lowerCAmelCase				,  {'sequence': ANY(lowerCAmelCase   ), 'labels': [ANY(lowerCAmelCase   )], 'scores': [ANY(lowerCAmelCase   )]}   )

        _lowercase      			=classifier('Who are you voting for in 2020?'				,  candidate_labels='politics, public health'   )
        self.assertEqual(
            lowerCAmelCase				,  {'sequence': ANY(lowerCAmelCase   ), 'labels': [ANY(lowerCAmelCase   ), ANY(lowerCAmelCase   )], 'scores': [ANY(lowerCAmelCase   ), ANY(lowerCAmelCase   )]}   )
        self.assertAlmostEqual(sum(nested_simplify(outputs['scores']   )   )				,  1.0   )

        _lowercase      			=classifier('Who are you voting for in 2020?'				,  candidate_labels=['politics', 'public health']   )
        self.assertEqual(
            lowerCAmelCase				,  {'sequence': ANY(lowerCAmelCase   ), 'labels': [ANY(lowerCAmelCase   ), ANY(lowerCAmelCase   )], 'scores': [ANY(lowerCAmelCase   ), ANY(lowerCAmelCase   )]}   )
        self.assertAlmostEqual(sum(nested_simplify(outputs['scores']   )   )				,  1.0   )

        _lowercase      			=classifier(
            'Who are you voting for in 2020?'				,  candidate_labels='politics'				,  hypothesis_template='This text is about {}'   )
        self.assertEqual(lowerCAmelCase				,  {'sequence': ANY(lowerCAmelCase   ), 'labels': [ANY(lowerCAmelCase   )], 'scores': [ANY(lowerCAmelCase   )]}   )

        # https://github.com/huggingface/transformers/issues/13846
        _lowercase      			=classifier(['I am happy']				,  ['positive', 'negative']   )
        self.assertEqual(
            lowerCAmelCase				,  [
                {'sequence': ANY(lowerCAmelCase   ), 'labels': [ANY(lowerCAmelCase   ), ANY(lowerCAmelCase   )], 'scores': [ANY(lowerCAmelCase   ), ANY(lowerCAmelCase   )]}
                for i in range(1   )
            ]				,  )
        _lowercase      			=classifier(['I am happy', 'I am sad']				,  ['positive', 'negative']   )
        self.assertEqual(
            lowerCAmelCase				,  [
                {'sequence': ANY(lowerCAmelCase   ), 'labels': [ANY(lowerCAmelCase   ), ANY(lowerCAmelCase   )], 'scores': [ANY(lowerCAmelCase   ), ANY(lowerCAmelCase   )]}
                for i in range(2   )
            ]				,  )

        with self.assertRaises(lowerCAmelCase   ):
              classifier(''				,  candidate_labels='politics'   )

        with self.assertRaises(lowerCAmelCase   ):
              classifier(lowerCAmelCase				,  candidate_labels='politics'   )

        with self.assertRaises(lowerCAmelCase   ):
              classifier('Who are you voting for in 2020?'				,  candidate_labels=''   )

        with self.assertRaises(lowerCAmelCase   ):
              classifier('Who are you voting for in 2020?'				,  candidate_labels=lowerCAmelCase   )

        with self.assertRaises(lowerCAmelCase   ):
              classifier(
                  'Who are you voting for in 2020?'				,  candidate_labels='politics'				,  hypothesis_template='Not formatting template'				,  )

        with self.assertRaises(lowerCAmelCase   ):
              classifier(
                  'Who are you voting for in 2020?'				,  candidate_labels='politics'				,  hypothesis_template=lowerCAmelCase				,  )

        self.run_entailment_id(lowerCAmelCase   )




  def     A__	(							self				,  lowerCAmelCase   )    ->					int:
        '''simple docstring'''






        _lowercase      			=zero_shot_classifier.model.config
        _lowercase      			=config.labelaid
        _lowercase      			=zero_shot_classifier.entailment_id

        _lowercase      			={'LABEL_0': 0, 'LABEL_1': 1, 'LABEL_2': 2}
        self.assertEqual(zero_shot_classifier.entailment_id				,  -1   )

        _lowercase      			={'entailment': 0, 'neutral': 1, 'contradiction': 2}
        self.assertEqual(zero_shot_classifier.entailment_id				,  0   )

        _lowercase      			={'ENTAIL': 0, 'NON-ENTAIL': 1}
        self.assertEqual(zero_shot_classifier.entailment_id				,  0   )

        _lowercase      			={'ENTAIL': 2, 'NEUTRAL': 1, 'CONTR': 0}
        self.assertEqual(zero_shot_classifier.entailment_id				,  2   )

        _lowercase      			=original_labelaid
        self.assertEqual(lowerCAmelCase				,  zero_shot_classifier.entailment_id   )




  @require_torch
  def     A__	(							self   )    ->					str:
        '''simple docstring'''






        _lowercase      			=pipeline(
            'zero-shot-classification'				,  model='sshleifer/tiny-distilbert-base-cased-distilled-squad'				,  framework='pt'				,  )
        # There was a regression in 4.10 for this
        # Adding a test so we don't make the mistake again.
        # https://github.com/huggingface/transformers/issues/13381#issuecomment-912343499
        zero_shot_classifier(
            'Who are you voting for in 2020?' * 100				,  candidate_labels=['politics', 'public health', 'science']   )




  @require_torch
  def     A__	(							self   )    ->					str:
        '''simple docstring'''






        _lowercase      			=pipeline(
            'zero-shot-classification'				,  model='sshleifer/tiny-distilbert-base-cased-distilled-squad'				,  framework='pt'				,  )
        _lowercase      			=zero_shot_classifier(
            'Who are you voting for in 2020?'				,  candidate_labels=['politics', 'public health', 'science']   )

        self.assertEqual(
            nested_simplify(lowerCAmelCase   )				,  {
                'sequence': 'Who are you voting for in 2020?',
                'labels': ['science', 'public health', 'politics'],
                'scores': [0.333, 0.333, 0.333],
            }				,  )




  @require_tf
  def     A__	(							self   )    ->					Union[str, Any]:
        '''simple docstring'''






        _lowercase      			=pipeline(
            'zero-shot-classification'				,  model='sshleifer/tiny-distilbert-base-cased-distilled-squad'				,  framework='tf'				,  )
        _lowercase      			=zero_shot_classifier(
            'Who are you voting for in 2020?'				,  candidate_labels=['politics', 'public health', 'science']   )

        self.assertEqual(
            nested_simplify(lowerCAmelCase   )				,  {
                'sequence': 'Who are you voting for in 2020?',
                'labels': ['science', 'public health', 'politics'],
                'scores': [0.333, 0.333, 0.333],
            }				,  )




  @slow
  @require_torch
  def     A__	(							self   )    ->					str:
        '''simple docstring'''






        _lowercase      			=pipeline('zero-shot-classification'				,  model='roberta-large-mnli'				,  framework='pt'   )
        _lowercase      			=zero_shot_classifier(
            'Who are you voting for in 2020?'				,  candidate_labels=['politics', 'public health', 'science']   )

        self.assertEqual(
            nested_simplify(lowerCAmelCase   )				,  {
                'sequence': 'Who are you voting for in 2020?',
                'labels': ['politics', 'public health', 'science'],
                'scores': [0.976, 0.015, 0.009],
            }				,  )
        _lowercase      			=zero_shot_classifier(
            'The dominant sequence transduction models are based on complex recurrent or convolutional neural networks'
            ' in an encoder-decoder configuration. The best performing models also connect the encoder and decoder'
            ' through an attention mechanism. We propose a new simple network architecture, the Transformer, based'
            ' solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two'
            ' machine translation tasks show these models to be superior in quality while being more parallelizable'
            ' and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014'
            ' English-to-German translation task, improving over the existing best results, including ensembles by'
            ' over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new'
            ' single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small'
            ' fraction of the training costs of the best models from the literature. We show that the Transformer'
            ' generalizes well to other tasks by applying it successfully to English constituency parsing both with'
            ' large and limited training data.'				,  candidate_labels=['machine learning', 'statistics', 'translation', 'vision']				,  multi_label=lowerCAmelCase				,  )
        self.assertEqual(
            nested_simplify(lowerCAmelCase   )				,  {
                'sequence': (
                    'The dominant sequence transduction models are based on complex recurrent or convolutional neural'
                    ' networks in an encoder-decoder configuration. The best performing models also connect the'
                    ' encoder and decoder through an attention mechanism. We propose a new simple network'
                    ' architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence'
                    ' and convolutions entirely. Experiments on two machine translation tasks show these models to be'
                    ' superior in quality while being more parallelizable and requiring significantly less time to'
                    ' train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,'
                    ' improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014'
                    ' English-to-French translation task, our model establishes a new single-model state-of-the-art'
                    ' BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training'
                    ' costs of the best models from the literature. We show that the Transformer generalizes well to'
                    ' other tasks by applying it successfully to English constituency parsing both with large and'
                    ' limited training data.'
                ),
                'labels': ['translation', 'machine learning', 'vision', 'statistics'],
                'scores': [0.817, 0.713, 0.018, 0.018],
            }				,  )




  @slow
  @require_tf
  def     A__	(							self   )    ->					Union[str, Any]:
        '''simple docstring'''






        _lowercase      			=pipeline('zero-shot-classification'				,  model='roberta-large-mnli'				,  framework='tf'   )
        _lowercase      			=zero_shot_classifier(
            'Who are you voting for in 2020?'				,  candidate_labels=['politics', 'public health', 'science']   )

        self.assertEqual(
            nested_simplify(lowerCAmelCase   )				,  {
                'sequence': 'Who are you voting for in 2020?',
                'labels': ['politics', 'public health', 'science'],
                'scores': [0.976, 0.015, 0.009],
            }				,  )
        _lowercase      			=zero_shot_classifier(
            'The dominant sequence transduction models are based on complex recurrent or convolutional neural networks'
            ' in an encoder-decoder configuration. The best performing models also connect the encoder and decoder'
            ' through an attention mechanism. We propose a new simple network architecture, the Transformer, based'
            ' solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two'
            ' machine translation tasks show these models to be superior in quality while being more parallelizable'
            ' and requiring significantly less time to train. Our model achieves 28.4 BLEU on the WMT 2014'
            ' English-to-German translation task, improving over the existing best results, including ensembles by'
            ' over 2 BLEU. On the WMT 2014 English-to-French translation task, our model establishes a new'
            ' single-model state-of-the-art BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small'
            ' fraction of the training costs of the best models from the literature. We show that the Transformer'
            ' generalizes well to other tasks by applying it successfully to English constituency parsing both with'
            ' large and limited training data.'				,  candidate_labels=['machine learning', 'statistics', 'translation', 'vision']				,  multi_label=lowerCAmelCase				,  )
        self.assertEqual(
            nested_simplify(lowerCAmelCase   )				,  {
                'sequence': (
                    'The dominant sequence transduction models are based on complex recurrent or convolutional neural'
                    ' networks in an encoder-decoder configuration. The best performing models also connect the'
                    ' encoder and decoder through an attention mechanism. We propose a new simple network'
                    ' architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence'
                    ' and convolutions entirely. Experiments on two machine translation tasks show these models to be'
                    ' superior in quality while being more parallelizable and requiring significantly less time to'
                    ' train. Our model achieves 28.4 BLEU on the WMT 2014 English-to-German translation task,'
                    ' improving over the existing best results, including ensembles by over 2 BLEU. On the WMT 2014'
                    ' English-to-French translation task, our model establishes a new single-model state-of-the-art'
                    ' BLEU score of 41.8 after training for 3.5 days on eight GPUs, a small fraction of the training'
                    ' costs of the best models from the literature. We show that the Transformer generalizes well to'
                    ' other tasks by applying it successfully to English constituency parsing both with large and'
                    ' limited training data.'
                ),
                'labels': ['translation', 'machine learning', 'vision', 'statistics'],
                'scores': [0.817, 0.713, 0.018, 0.018],
            }				,  )





import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_vision_available


if is_vision_available():
  from PIL import Image

  from transformers import ChineseCLIPImageProcessor, ChineseCLIPProcessor





@require_vision
class 					__lowerCAmelCase	(   unittest.TestCase				):




  def     A__	(							self   )    ->					Tuple:
        '''simple docstring'''






        _lowercase      			=tempfile.mkdtemp()

        _lowercase      			=[
            '[UNK]',
            '[CLS]',
            '[SEP]',
            '[PAD]',
            '[MASK]',
            '的',
            '价',
            '格',
            '是',
            '15',
            '便',
            'alex',
            '##andra',
            '，',
            '。',
            '-',
            't',
            'shirt',
        ]
        _lowercase      			=os.path.join(self.tmpdirname				,  VOCAB_FILES_NAMES['vocab_file']   )
        with open(self.vocab_file				,  'w'				,  encoding='utf-8'   ) as vocab_writer:
              vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]   )   )

        _lowercase      			={
            'do_resize': True,
            'size': {'height': 224, 'width': 224},
            'do_center_crop': True,
            'crop_size': {'height': 18, 'width': 18},
            'do_normalize': True,
            'image_mean': [0.48145466, 0.4578275, 0.40821073],
            'image_std': [0.26862954, 0.26130258, 0.27577711],
            'do_convert_rgb': True,
        }
        _lowercase      			=os.path.join(self.tmpdirname				,  lowerCAmelCase   )
        with open(self.image_processor_file				,  'w'				,  encoding='utf-8'   ) as fp:
              json.dump(lowerCAmelCase				,  lowerCAmelCase   )




  def     A__	(							self				,  **lowerCAmelCase   )    ->					Optional[int]:
        '''simple docstring'''






        return BertTokenizer.from_pretrained(self.tmpdirname				,  **lowerCAmelCase   )




  def     A__	(							self				,  **lowerCAmelCase   )    ->					Optional[Any]:
        '''simple docstring'''






        return BertTokenizerFast.from_pretrained(self.tmpdirname				,  **lowerCAmelCase   )




  def     A__	(							self				,  **lowerCAmelCase   )    ->					Any:
        '''simple docstring'''






        return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname				,  **lowerCAmelCase   )




  def     A__	(							self   )    ->					List[str]:
        '''simple docstring'''






        shutil.rmtree(self.tmpdirname   )




  def     A__	(							self   )    ->					Tuple:
        '''simple docstring'''






        _lowercase      			=[np.random.randint(255				,  size=(3, 30, 400)				,  dtype=np.uinta   )]

        _lowercase      			=[Image.fromarray(np.moveaxis(lowerCAmelCase				,  0				,  -1   )   ) for x in image_inputs]

        return image_inputs




  def     A__	(							self   )    ->					str:
        '''simple docstring'''






        _lowercase      			=self.get_tokenizer()
        _lowercase      			=self.get_rust_tokenizer()
        _lowercase      			=self.get_image_processor()

        _lowercase      			=ChineseCLIPProcessor(tokenizer=lowerCAmelCase				,  image_processor=lowerCAmelCase   )
        processor_slow.save_pretrained(self.tmpdirname   )
        _lowercase      			=ChineseCLIPProcessor.from_pretrained(self.tmpdirname				,  use_fast=lowerCAmelCase   )

        _lowercase      			=ChineseCLIPProcessor(tokenizer=lowerCAmelCase				,  image_processor=lowerCAmelCase   )
        processor_fast.save_pretrained(self.tmpdirname   )
        _lowercase      			=ChineseCLIPProcessor.from_pretrained(self.tmpdirname   )

        self.assertEqual(processor_slow.tokenizer.get_vocab()				,  tokenizer_slow.get_vocab()   )
        self.assertEqual(processor_fast.tokenizer.get_vocab()				,  tokenizer_fast.get_vocab()   )
        self.assertEqual(tokenizer_slow.get_vocab()				,  tokenizer_fast.get_vocab()   )
        self.assertIsInstance(processor_slow.tokenizer				,  lowerCAmelCase   )
        self.assertIsInstance(processor_fast.tokenizer				,  lowerCAmelCase   )

        self.assertEqual(processor_slow.image_processor.to_json_string()				,  image_processor.to_json_string()   )
        self.assertEqual(processor_fast.image_processor.to_json_string()				,  image_processor.to_json_string()   )
        self.assertIsInstance(processor_slow.image_processor				,  lowerCAmelCase   )
        self.assertIsInstance(processor_fast.image_processor				,  lowerCAmelCase   )




  def     A__	(							self   )    ->					str:
        '''simple docstring'''






        _lowercase      			=ChineseCLIPProcessor(tokenizer=self.get_tokenizer()				,  image_processor=self.get_image_processor()   )
        processor.save_pretrained(self.tmpdirname   )

        _lowercase      			=self.get_tokenizer(cls_token='(CLS)'				,  sep_token='(SEP)'   )
        _lowercase      			=self.get_image_processor(do_normalize=lowerCAmelCase   )

        _lowercase      			=ChineseCLIPProcessor.from_pretrained(
            self.tmpdirname				,  cls_token='(CLS)'				,  sep_token='(SEP)'				,  do_normalize=lowerCAmelCase   )

        self.assertEqual(processor.tokenizer.get_vocab()				,  tokenizer_add_kwargs.get_vocab()   )
        self.assertIsInstance(processor.tokenizer				,  lowerCAmelCase   )

        self.assertEqual(processor.image_processor.to_json_string()				,  image_processor_add_kwargs.to_json_string()   )
        self.assertIsInstance(processor.image_processor				,  lowerCAmelCase   )




  def     A__	(							self   )    ->					List[str]:
        '''simple docstring'''






        _lowercase      			=self.get_image_processor()
        _lowercase      			=self.get_tokenizer()

        _lowercase      			=ChineseCLIPProcessor(tokenizer=lowerCAmelCase				,  image_processor=lowerCAmelCase   )

        _lowercase      			=self.prepare_image_inputs()

        _lowercase      			=image_processor(lowerCAmelCase				,  return_tensors='np'   )
        _lowercase      			=processor(images=lowerCAmelCase				,  return_tensors='np'   )

        for key in input_feat_extract.keys():
              self.assertAlmostEqual(input_feat_extract[key].sum()				,  input_processor[key].sum()				,  delta=1e-2   )




  def     A__	(							self   )    ->					List[str]:
        '''simple docstring'''






        _lowercase      			=self.get_image_processor()
        _lowercase      			=self.get_tokenizer()

        _lowercase      			=ChineseCLIPProcessor(tokenizer=lowerCAmelCase				,  image_processor=lowerCAmelCase   )

        _lowercase      			='Alexandra，T-shirt的价格是15便士。'

        _lowercase      			=processor(text=lowerCAmelCase   )

        _lowercase      			=tokenizer(lowerCAmelCase   )

        for key in encoded_tok.keys():
              self.assertListEqual(encoded_tok[key]				,  encoded_processor[key]   )




  def     A__	(							self   )    ->					Dict:
        '''simple docstring'''






        _lowercase      			=self.get_image_processor()
        _lowercase      			=self.get_tokenizer()

        _lowercase      			=ChineseCLIPProcessor(tokenizer=lowerCAmelCase				,  image_processor=lowerCAmelCase   )

        _lowercase      			='Alexandra，T-shirt的价格是15便士。'
        _lowercase      			=self.prepare_image_inputs()

        _lowercase      			=processor(text=lowerCAmelCase				,  images=lowerCAmelCase   )

        self.assertListEqual(list(inputs.keys()   )				,  ['input_ids', 'token_type_ids', 'attention_mask', 'pixel_values']   )

        # test if it raises when no input is passed
        with pytest.raises(lowerCAmelCase   ):
              processor()




  def     A__	(							self   )    ->					Optional[Any]:
        '''simple docstring'''






        _lowercase      			=self.get_image_processor()
        _lowercase      			=self.get_tokenizer()

        _lowercase      			=ChineseCLIPProcessor(tokenizer=lowerCAmelCase				,  image_processor=lowerCAmelCase   )

        _lowercase      			=[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

        _lowercase      			=processor.batch_decode(lowerCAmelCase   )
        _lowercase      			=tokenizer.batch_decode(lowerCAmelCase   )

        self.assertListEqual(lowerCAmelCase				,  lowerCAmelCase   )




  def     A__	(							self   )    ->					str:
        '''simple docstring'''






        _lowercase      			=self.get_image_processor()
        _lowercase      			=self.get_tokenizer()

        _lowercase      			=ChineseCLIPProcessor(tokenizer=lowerCAmelCase				,  image_processor=lowerCAmelCase   )

        _lowercase      			='Alexandra，T-shirt的价格是15便士。'
        _lowercase      			=self.prepare_image_inputs()

        _lowercase      			=processor(text=lowerCAmelCase				,  images=lowerCAmelCase   )

        self.assertListEqual(list(inputs.keys()   )				,  processor.model_input_names   )


