
'''simple docstring'''






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  __magic_name__							(		unittest.TestCase    ):
       UpperCAmelCase										=MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
       UpperCAmelCase										=TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case)						->  List[str]:




          '''simple docstring'''
          _UpperCAmelCase       :       Tuple							   =ZeroShotClassificationPipeline(
              model=snake_case  ,							tokenizer=snake_case  ,							candidate_labels=['polics', 'health'])
          return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case)						->  Optional[Any]:




          '''simple docstring'''
          _UpperCAmelCase       :       Union[str, Any]							   =classifier('Who are you voting for in 2020?'  ,							candidate_labels='politics')
          self.assertEqual(snake_case  ,							{'sequence': ANY(snake_case), 'labels': [ANY(snake_case)], 'scores': [ANY(snake_case)]})

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

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

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

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

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

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

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

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

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

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

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

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

          self.run_entailment_id(snake_case)






       def       lowerCAmelCase		(      self  ,							snake_case)						->  int:




          '''simple docstring'''
          _UpperCAmelCase       :       Any							   =zero_shot_classifier.model.config
          _UpperCAmelCase       :       Any							   =config.labelaid
          _UpperCAmelCase       :       Union[str, Any]							   =zero_shot_classifier.entailment_id

          _UpperCAmelCase       :       List[Any]							   ={'LABEL_0': 0, 'LABEL_1': 1, 'LABEL_2': 2}
          self.assertEqual(zero_shot_classifier.entailment_id  ,							-1)

          _UpperCAmelCase       :       List[Any]							   ={'entailment': 0, 'neutral': 1, 'contradiction': 2}
          self.assertEqual(zero_shot_classifier.entailment_id  ,							0)

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

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

          _UpperCAmelCase       :       int							   =original_labelaid
          self.assertEqual(snake_case  ,							zero_shot_classifier.entailment_id)






       @require_torch
       def       lowerCAmelCase		(      self)						->  Dict:




          '''simple docstring'''
          _UpperCAmelCase       :       List[Any]							   =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?' * 1_0_0  ,							candidate_labels=['politics', 'public health', 'science'])






       @require_torch
       def       lowerCAmelCase		(      self)						->  Tuple:




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

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






       @require_tf
       def       lowerCAmelCase		(      self)						->  Any:




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

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






       @slow
       @require_torch
       def       lowerCAmelCase		(      self)						->  Dict:




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

          self.assertEqual(
              nested_simplify(snake_case)  ,							{
                  'sequence': 'Who are you voting for in 2020?',
                  'labels': ['politics', 'public health', 'science'],
                  'scores': [0.9_76, 0.0_15, 0.0_09],
              }  ,							)
          _UpperCAmelCase       :       Optional[int]							   =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=snake_case  ,							)
          self.assertEqual(
              nested_simplify(snake_case)  ,							{
                  '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.8_17, 0.7_13, 0.0_18, 0.0_18],
              }  ,							)






       @slow
       @require_tf
       def       lowerCAmelCase		(      self)						->  Optional[int]:




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

          self.assertEqual(
              nested_simplify(snake_case)  ,							{
                  'sequence': 'Who are you voting for in 2020?',
                  'labels': ['politics', 'public health', 'science'],
                  'scores': [0.9_76, 0.0_15, 0.0_09],
              }  ,							)
          _UpperCAmelCase       :       Any							   =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=snake_case  ,							)
          self.assertEqual(
              nested_simplify(snake_case)  ,							{
                  '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.8_17, 0.7_13, 0.0_18, 0.0_18],
              }  ,							)





'''simple docstring'''






from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase							=logging.get_logger(__name__)

lowercase							={
    'vinvino02/glpn-kitti': 'https://huggingface.co/vinvino02/glpn-kitti/resolve/main/config.json',
    # See all GLPN models at https://huggingface.co/models?filter=glpn
}






class  __magic_name__							(		lowerCAmelCase    ):
       UpperCAmelCase										="glpn"






       def __init__(      self  ,							snake_case=3  ,							snake_case=4  ,							snake_case=[2, 2, 2, 2]  ,							snake_case=[8, 4, 2, 1]  ,							snake_case=[3_2, 6_4, 1_6_0, 2_5_6]  ,							snake_case=[7, 3, 3, 3]  ,							snake_case=[4, 2, 2, 2]  ,							snake_case=[1, 2, 5, 8]  ,							snake_case=[4, 4, 4, 4]  ,							snake_case="gelu"  ,							snake_case=0.0  ,							snake_case=0.0  ,							snake_case=0.02  ,							snake_case=0.1  ,							snake_case=1E-6  ,							snake_case=6_4  ,							snake_case=1_0  ,							snake_case=-1  ,							**snake_case  ,							)						->  Tuple:




          '''simple docstring'''
          super().__init__(**snake_case)

          _UpperCAmelCase       :       Any							   =num_channels
          _UpperCAmelCase       :       List[str]							   =num_encoder_blocks
          _UpperCAmelCase       :       Optional[Any]							   =depths
          _UpperCAmelCase       :       str							   =sr_ratios
          _UpperCAmelCase       :       Dict							   =hidden_sizes
          _UpperCAmelCase       :       List[str]							   =patch_sizes
          _UpperCAmelCase       :       Any							   =strides
          _UpperCAmelCase       :       List[str]							   =mlp_ratios
          _UpperCAmelCase       :       Dict							   =num_attention_heads
          _UpperCAmelCase       :       List[str]							   =hidden_act
          _UpperCAmelCase       :       int							   =hidden_dropout_prob
          _UpperCAmelCase       :       List[Any]							   =attention_probs_dropout_prob
          _UpperCAmelCase       :       Union[str, Any]							   =initializer_range
          _UpperCAmelCase       :       Tuple							   =drop_path_rate
          _UpperCAmelCase       :       str							   =layer_norm_eps
          _UpperCAmelCase       :       Optional[int]							   =decoder_hidden_size
          _UpperCAmelCase       :       List[str]							   =max_depth
          _UpperCAmelCase       :       Dict							   =head_in_index

