




'''simple docstring'''


import gc
import unittest

import numpy as np
import torch
from torch.backends.cuda import sdp_kernel

from diffusers import (
    CMStochasticIterativeScheduler,
    ConsistencyModelPipeline,
    UNetaDModel,
)
from diffusers.utils import randn_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu

from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()





class  __lowercase    (	__magic_name__							,				unittest.TestCase			):
   _a    						=   ConsistencyModelPipeline
   _a    						=   UNCONDITIONAL_IMAGE_GENERATION_PARAMS
   _a    						=   UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS

   # Override required_optional_params to remove num_images_per_prompt
   _a    						=   frozenset(
       [
           """num_inference_steps""",
           """generator""",
           """latents""",
           """output_type""",
           """return_dict""",
           """callback""",
           """callback_steps""",
       ]			)







   @property
   def 		UpperCamelCase__      (						self   )					->     Tuple:
     __a								=       UNetaDModel.from_pretrained(
         'diffusers/consistency-models-test'   ,				subfolder='test_unet'   ,				)
     return unet







   @property
   def 		UpperCamelCase__      (						self   )					->     Tuple:
     __a								=       UNetaDModel.from_pretrained(
         'diffusers/consistency-models-test'   ,				subfolder='test_unet_class_cond'   ,				)
     return unet







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase=False   )					->     Optional[Any]:
     if class_cond:
       __a								=       self.dummy_cond_unet
     else:
       __a								=       self.dummy_uncond_unet

     # Default to CM multistep sampler
     __a								=       CMStochasticIterativeScheduler(
         num_train_timesteps=40   ,				sigma_min=0.002   ,				sigma_max=80.0   ,				)

     __a								=       {
         'unet': unet,
         'scheduler': scheduler,
     }

     return components







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase=0   )					->     Union[str, Any]:
     if str(UpperCamelCase   ).startswith('mps'   ):
       __a								=       torch.manual_seed(UpperCamelCase   )
     else:
       __a								=       torch.Generator(device=UpperCamelCase   ).manual_seed(UpperCamelCase   )

     __a								=       {
         'batch_size': 1,
         'num_inference_steps': None,
         'timesteps': [22, 0],
         'generator': generator,
         'output_type': 'np',
     }

     return inputs







   def 		UpperCamelCase__      (						self   )					->     Union[str, Any]:
     __a								=       'cpu'  # ensure determinism for the device-dependent torch.Generator
     __a								=       self.get_dummy_components()
     __a								=       ConsistencyModelPipeline(**UpperCamelCase   )
     __a								=       pipe.to(UpperCamelCase   )
     pipe.set_progress_bar_config(disable=UpperCamelCase   )

     __a								=       self.get_dummy_inputs(UpperCamelCase   )
     __a								=       pipe(**UpperCamelCase   ).images
     assert image.shape == (1, 32, 32, 3)

     __a								=       image[0, -3:, -3:, -1]
     __a								=       np.array([0.3_572, 0.6_273, 0.4_031, 0.3_961, 0.4_321, 0.5_730, 0.5_266, 0.4_780, 0.5_004]   )

     assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-3







   def 		UpperCamelCase__      (						self   )					->     Dict:
     __a								=       'cpu'  # ensure determinism for the device-dependent torch.Generator
     __a								=       self.get_dummy_components(class_cond=UpperCamelCase   )
     __a								=       ConsistencyModelPipeline(**UpperCamelCase   )
     __a								=       pipe.to(UpperCamelCase   )
     pipe.set_progress_bar_config(disable=UpperCamelCase   )

     __a								=       self.get_dummy_inputs(UpperCamelCase   )
     __a								=       0
     __a								=       pipe(**UpperCamelCase   ).images
     assert image.shape == (1, 32, 32, 3)

     __a								=       image[0, -3:, -3:, -1]
     __a								=       np.array([0.3_572, 0.6_273, 0.4_031, 0.3_961, 0.4_321, 0.5_730, 0.5_266, 0.4_780, 0.5_004]   )

     assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-3







   def 		UpperCamelCase__      (						self   )					->     Dict:
     __a								=       'cpu'  # ensure determinism for the device-dependent torch.Generator
     __a								=       self.get_dummy_components()
     __a								=       ConsistencyModelPipeline(**UpperCamelCase   )
     __a								=       pipe.to(UpperCamelCase   )
     pipe.set_progress_bar_config(disable=UpperCamelCase   )

     __a								=       self.get_dummy_inputs(UpperCamelCase   )
     __a								=       1
     __a								=       None
     __a								=       pipe(**UpperCamelCase   ).images
     assert image.shape == (1, 32, 32, 3)

     __a								=       image[0, -3:, -3:, -1]
     __a								=       np.array([0.5_004, 0.5_004, 0.4_994, 0.5_008, 0.4_976, 0.5_018, 0.4_990, 0.4_982, 0.4_987]   )

     assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-3







   def 		UpperCamelCase__      (						self   )					->     List[Any]:
     __a								=       'cpu'  # ensure determinism for the device-dependent torch.Generator
     __a								=       self.get_dummy_components(class_cond=UpperCamelCase   )
     __a								=       ConsistencyModelPipeline(**UpperCamelCase   )
     __a								=       pipe.to(UpperCamelCase   )
     pipe.set_progress_bar_config(disable=UpperCamelCase   )

     __a								=       self.get_dummy_inputs(UpperCamelCase   )
     __a								=       1
     __a								=       None
     __a								=       0
     __a								=       pipe(**UpperCamelCase   ).images
     assert image.shape == (1, 32, 32, 3)

     __a								=       image[0, -3:, -3:, -1]
     __a								=       np.array([0.5_004, 0.5_004, 0.4_994, 0.5_008, 0.4_976, 0.5_018, 0.4_990, 0.4_982, 0.4_987]   )

     assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-3





@slow
@require_torch_gpu
class  __lowercase    (	unittest.TestCase			):







   def 		UpperCamelCase__      (						self   )					->     Tuple:
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase=0   ,				UpperCamelCase=False   ,				UpperCamelCase="cpu"   ,				UpperCamelCase=torch.floataa   ,				UpperCamelCase=(1, 3, 64, 64)   )					->     str:
     __a								=       torch.manual_seed(UpperCamelCase   )

     __a								=       {
         'num_inference_steps': None,
         'timesteps': [22, 0],
         'class_labels': 0,
         'generator': generator,
         'output_type': 'np',
     }

     if get_fixed_latents:
       __a								=       self.get_fixed_latents(seed=UpperCamelCase   ,				device=UpperCamelCase   ,				dtype=UpperCamelCase   ,				shape=UpperCamelCase   )
       __a								=       latents

     return inputs







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase=0   ,				UpperCamelCase="cpu"   ,				UpperCamelCase=torch.floataa   ,				UpperCamelCase=(1, 3, 64, 64)   )					->     Dict:
     if type(UpperCamelCase   ) == str:
       __a								=       torch.device(UpperCamelCase   )
     __a								=       torch.Generator(device=UpperCamelCase   ).manual_seed(UpperCamelCase   )
     __a								=       randn_tensor(UpperCamelCase   ,				generator=UpperCamelCase   ,				device=UpperCamelCase   ,				dtype=UpperCamelCase   )
     return latents







   def 		UpperCamelCase__      (						self   )					->     List[str]:
     __a								=       UNetaDModel.from_pretrained('diffusers/consistency_models'   ,				subfolder='diffusers_cd_imagenet64_l2'   )
     __a								=       CMStochasticIterativeScheduler(
         num_train_timesteps=40   ,				sigma_min=0.002   ,				sigma_max=80.0   ,				)
     __a								=       ConsistencyModelPipeline(unet=UpperCamelCase   ,				scheduler=UpperCamelCase   )
     pipe.to(torch_device=UpperCamelCase   )
     pipe.set_progress_bar_config(disable=UpperCamelCase   )

     __a								=       self.get_inputs()
     __a								=       pipe(**UpperCamelCase   ).images
     assert image.shape == (1, 64, 64, 3)

     __a								=       image[0, -3:, -3:, -1]

     __a								=       np.array([0.0_888, 0.0_881, 0.0_666, 0.0_479, 0.0_292, 0.0_195, 0.0_201, 0.0_163, 0.0_254]   )

     assert np.abs(image_slice.flatten() - expected_slice   ).max() < 2e-2







   def 		UpperCamelCase__      (						self   )					->     Union[str, Any]:
     __a								=       UNetaDModel.from_pretrained('diffusers/consistency_models'   ,				subfolder='diffusers_cd_imagenet64_l2'   )
     __a								=       CMStochasticIterativeScheduler(
         num_train_timesteps=40   ,				sigma_min=0.002   ,				sigma_max=80.0   ,				)
     __a								=       ConsistencyModelPipeline(unet=UpperCamelCase   ,				scheduler=UpperCamelCase   )
     pipe.to(torch_device=UpperCamelCase   )
     pipe.set_progress_bar_config(disable=UpperCamelCase   )

     __a								=       self.get_inputs()
     __a								=       1
     __a								=       None
     __a								=       pipe(**UpperCamelCase   ).images
     assert image.shape == (1, 64, 64, 3)

     __a								=       image[0, -3:, -3:, -1]

     __a								=       np.array([0.0_340, 0.0_152, 0.0_063, 0.0_267, 0.0_221, 0.0_107, 0.0_416, 0.0_186, 0.0_217]   )

     assert np.abs(image_slice.flatten() - expected_slice   ).max() < 2e-2







   @require_torch_a
   def 		UpperCamelCase__      (						self   )					->     List[str]:
     __a								=       UNetaDModel.from_pretrained('diffusers/consistency_models'   ,				subfolder='diffusers_cd_imagenet64_l2'   )
     __a								=       CMStochasticIterativeScheduler(
         num_train_timesteps=40   ,				sigma_min=0.002   ,				sigma_max=80.0   ,				)
     __a								=       ConsistencyModelPipeline(unet=UpperCamelCase   ,				scheduler=UpperCamelCase   )
     pipe.to(torch_device=UpperCamelCase   ,				torch_dtype=torch.floataa   )
     pipe.set_progress_bar_config(disable=UpperCamelCase   )

     __a								=       self.get_inputs(get_fixed_latents=UpperCamelCase   ,				device=UpperCamelCase   )
     # Ensure usage of flash attention in torch 2.0
     with sdp_kernel(enable_flash=UpperCamelCase   ,				enable_math=UpperCamelCase   ,				enable_mem_efficient=UpperCamelCase   ):
       __a								=       pipe(**UpperCamelCase   ).images
     assert image.shape == (1, 64, 64, 3)

     __a								=       image[0, -3:, -3:, -1]

     __a								=       np.array([0.1_875, 0.1_428, 0.1_289, 0.2_151, 0.2_092, 0.1_477, 0.1_877, 0.1_641, 0.1_353]   )

     assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-3







   @require_torch_a
   def 		UpperCamelCase__      (						self   )					->     Any:
     __a								=       UNetaDModel.from_pretrained('diffusers/consistency_models'   ,				subfolder='diffusers_cd_imagenet64_l2'   )
     __a								=       CMStochasticIterativeScheduler(
         num_train_timesteps=40   ,				sigma_min=0.002   ,				sigma_max=80.0   ,				)
     __a								=       ConsistencyModelPipeline(unet=UpperCamelCase   ,				scheduler=UpperCamelCase   )
     pipe.to(torch_device=UpperCamelCase   ,				torch_dtype=torch.floataa   )
     pipe.set_progress_bar_config(disable=UpperCamelCase   )

     __a								=       self.get_inputs(get_fixed_latents=UpperCamelCase   ,				device=UpperCamelCase   )
     __a								=       1
     __a								=       None
     # Ensure usage of flash attention in torch 2.0
     with sdp_kernel(enable_flash=UpperCamelCase   ,				enable_math=UpperCamelCase   ,				enable_mem_efficient=UpperCamelCase   ):
       __a								=       pipe(**UpperCamelCase   ).images
     assert image.shape == (1, 64, 64, 3)

     __a								=       image[0, -3:, -3:, -1]

     __a								=       np.array([0.1_663, 0.1_948, 0.2_275, 0.1_680, 0.1_204, 0.1_245, 0.1_858, 0.1_338, 0.2_095]   )

     assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-3









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





@is_pipeline_test
class  __lowercase    (	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 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   )					->     Optional[Any]:
     __a								=       ZeroShotClassificationPipeline(
         model=UpperCamelCase   ,				tokenizer=UpperCamelCase   ,				candidate_labels=['polics', 'health']   )
     return classifier, ["Who are you voting for in 2020?", "My stomach hurts."]







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   )					->     Tuple:
     __a								=       classifier('Who are you voting for in 2020?'   ,				candidate_labels='politics'   )
     self.assertEqual(UpperCamelCase   ,				{'sequence': ANY(UpperCamelCase   ), 'labels': [ANY(UpperCamelCase   )], 'scores': [ANY(UpperCamelCase   )]}   )

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

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

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

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

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

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

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

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

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

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

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

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

     self.run_entailment_id(UpperCamelCase   )







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   )					->     Optional[int]:
     __a								=       zero_shot_classifier.model.config
     __a								=       config.labelaid
     __a								=       zero_shot_classifier.entailment_id

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

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

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

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

     __a								=       original_labelaid
     self.assertEqual(UpperCamelCase   ,				zero_shot_classifier.entailment_id   )







   @require_torch
   def 		UpperCamelCase__      (						self   )					->     Tuple:
     __a								=       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 		UpperCamelCase__      (						self   )					->     List[str]:
     __a								=       pipeline(
         'zero-shot-classification'   ,				model='sshleifer/tiny-distilbert-base-cased-distilled-squad'   ,				framework='pt'   ,				)
     __a								=       zero_shot_classifier(
         'Who are you voting for in 2020?'   ,				candidate_labels=['politics', 'public health', 'science']   )

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







   @require_tf
   def 		UpperCamelCase__      (						self   )					->     Dict:
     __a								=       pipeline(
         'zero-shot-classification'   ,				model='sshleifer/tiny-distilbert-base-cased-distilled-squad'   ,				framework='tf'   ,				)
     __a								=       zero_shot_classifier(
         'Who are you voting for in 2020?'   ,				candidate_labels=['politics', 'public health', 'science']   )

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







   @slow
   @require_torch
   def 		UpperCamelCase__      (						self   )					->     List[str]:
     __a								=       pipeline('zero-shot-classification'   ,				model='roberta-large-mnli'   ,				framework='pt'   )
     __a								=       zero_shot_classifier(
         'Who are you voting for in 2020?'   ,				candidate_labels=['politics', 'public health', 'science']   )

     self.assertEqual(
         nested_simplify(UpperCamelCase   )   ,				{
             'sequence': 'Who are you voting for in 2020?',
             'labels': ['politics', 'public health', 'science'],
             'scores': [0.976, 0.015, 0.009],
         }   ,				)
     __a								=       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=UpperCamelCase   ,				)
     self.assertEqual(
         nested_simplify(UpperCamelCase   )   ,				{
             '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 		UpperCamelCase__      (						self   )					->     Union[str, Any]:
     __a								=       pipeline('zero-shot-classification'   ,				model='roberta-large-mnli'   ,				framework='tf'   )
     __a								=       zero_shot_classifier(
         'Who are you voting for in 2020?'   ,				candidate_labels=['politics', 'public health', 'science']   )

     self.assertEqual(
         nested_simplify(UpperCamelCase   )   ,				{
             'sequence': 'Who are you voting for in 2020?',
             'labels': ['politics', 'public health', 'science'],
             'scores': [0.976, 0.015, 0.009],
         }   ,				)
     __a								=       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=UpperCamelCase   ,				)
     self.assertEqual(
         nested_simplify(UpperCamelCase   )   ,				{
             '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],
         }   ,				)



