


"""simple docstring"""



import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu
class 					__magic_name__		(			unittest.TestCase     ):






       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()






       @property
       def  __snake_case						(   self  :    Optional[int]				):

              '''simple docstring'''






              lowercase		:List[Any]       							=				1
              lowercase		:Tuple       							=				3
              lowercase		:str       							=				(3_2, 3_2)

              lowercase		:Union[str, Any]       							=				floats_tensor((batch_size, num_channels) + sizes  ,     rng=random.Random(0				)				).to(snake_case__				)
              return image






       @property
       def  __snake_case						(   self  :    Optional[int]				):

              '''simple docstring'''






              torch.manual_seed(0				)
              lowercase		:Any       							=				UNetaDConditionModel(
                  block_out_channels=(3_2, 6_4)  ,     layers_per_block=2  ,     sample_size=3_2  ,     in_channels=4  ,     out_channels=4  ,     down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')  ,     up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')  ,     cross_attention_dim=3_2  ,     )
              return model






       @property
       def  __snake_case						(   self  :    str				):

              '''simple docstring'''






              torch.manual_seed(0				)
              lowercase		:List[str]       							=				AutoencoderKL(
                  block_out_channels=[3_2, 6_4]  ,     in_channels=3  ,     out_channels=3  ,     down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']  ,     up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']  ,     latent_channels=4  ,     )
              return model






       @property
       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              torch.manual_seed(0				)
              lowercase		:Optional[Any]       							=				CLIPTextConfig(
                  bos_token_id=0  ,     eos_token_id=2  ,     hidden_size=3_2  ,     intermediate_size=3_7  ,     layer_norm_eps=1e-0_5  ,     num_attention_heads=4  ,     num_hidden_layers=5  ,     pad_token_id=1  ,     vocab_size=1_0_0_0  ,     )
              return CLIPTextModel(snake_case__				)






       @property
       def  __snake_case						(   self  :    int				):

              '''simple docstring'''






              def extract(*snake_case__  :    Optional[int]  ,     **snake_case__  :    Any				):
                     class 					__magic_name__		:






                            def __init__(   self  :    Any				):

                                   '''simple docstring'''






                                   lowercase		:Tuple       							=				torch.ones([0]				)







                            def  __snake_case						(   self  :    List[Any]  ,     snake_case__  :    List[Any]				):

                                   '''simple docstring'''






                                   self.pixel_values.to(snake_case__				)
                                   return self







                     return Out()

              return extract






       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              lowercase		:str       							=				'''cpu'''  # ensure determinism for the device-dependent torch.Generator
              lowercase		:int       							=				self.dummy_cond_unet
              lowercase		:List[Any]       							=				DDIMScheduler(
                  beta_start=0.0_00_85  ,     beta_end=0.0_12  ,     beta_schedule='''scaled_linear'''  ,     clip_sample=snake_case__  ,     set_alpha_to_one=snake_case__  ,     )

              lowercase		:int       							=				self.dummy_vae
              lowercase		:int       							=				self.dummy_text_encoder
              lowercase		:List[str]       							=				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)

              # make sure here that pndm scheduler skips prk
              lowercase		:int       							=				StableDiffusionPipeline(
                  unet=snake_case__  ,     scheduler=snake_case__  ,     vae=snake_case__  ,     text_encoder=snake_case__  ,     tokenizer=snake_case__  ,     safety_checker=snake_case__  ,     feature_extractor=self.dummy_extractor  ,     )
              lowercase		:Union[str, Any]       							=				sd_pipe.to(snake_case__				)
              sd_pipe.set_progress_bar_config(disable=snake_case__				)

              lowercase		:List[str]       							=				'''A painting of a squirrel eating a burger'''

              lowercase		:Dict       							=				torch.Generator(device=snake_case__				).manual_seed(0				)
              lowercase		:List[str]       							=				sd_pipe([prompt]  ,     generator=snake_case__  ,     guidance_scale=6.0  ,     num_inference_steps=2  ,     output_type='''np'''				)
              lowercase		:Any       							=				output.images

              lowercase		:Union[str, Any]       							=				torch.Generator(device=snake_case__				).manual_seed(0				)
              lowercase		:Dict       							=				sd_pipe(
                  [prompt]  ,     generator=snake_case__  ,     guidance_scale=6.0  ,     num_inference_steps=2  ,     output_type='''np'''  ,     return_dict=snake_case__  ,     )[0]

              lowercase		:int       							=				image[0, -3:, -3:, -1]
              lowercase		:Tuple       							=				image_from_tuple[0, -3:, -3:, -1]

              assert image.shape == (1, 6_4, 6_4, 3)
              lowercase		:Optional[Any]       							=				np.array([0.57_56, 0.61_18, 0.50_05, 0.50_41, 0.54_71, 0.47_26, 0.49_76, 0.48_65, 0.48_64]				)

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






       def  __snake_case						(   self  :    int				):

              '''simple docstring'''






              lowercase		:str       							=				'''cpu'''  # ensure determinism for the device-dependent torch.Generator
              lowercase		:str       							=				self.dummy_cond_unet
              lowercase		:List[str]       							=				PNDMScheduler(skip_prk_steps=snake_case__				)
              lowercase		:Union[str, Any]       							=				self.dummy_vae
              lowercase		:Dict       							=				self.dummy_text_encoder
              lowercase		:Tuple       							=				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)

              # make sure here that pndm scheduler skips prk
              lowercase		:Optional[int]       							=				StableDiffusionPipeline(
                  unet=snake_case__  ,     scheduler=snake_case__  ,     vae=snake_case__  ,     text_encoder=snake_case__  ,     tokenizer=snake_case__  ,     safety_checker=snake_case__  ,     feature_extractor=self.dummy_extractor  ,     )
              lowercase		:Union[str, Any]       							=				sd_pipe.to(snake_case__				)
              sd_pipe.set_progress_bar_config(disable=snake_case__				)

              lowercase		:int       							=				'''A painting of a squirrel eating a burger'''
              lowercase		:Dict       							=				torch.Generator(device=snake_case__				).manual_seed(0				)
              lowercase		:Dict       							=				sd_pipe([prompt]  ,     generator=snake_case__  ,     guidance_scale=6.0  ,     num_inference_steps=2  ,     output_type='''np'''				)

              lowercase		:Optional[int]       							=				output.images

              lowercase		:Any       							=				torch.Generator(device=snake_case__				).manual_seed(0				)
              lowercase		:Union[str, Any]       							=				sd_pipe(
                  [prompt]  ,     generator=snake_case__  ,     guidance_scale=6.0  ,     num_inference_steps=2  ,     output_type='''np'''  ,     return_dict=snake_case__  ,     )[0]

              lowercase		:Optional[int]       							=				image[0, -3:, -3:, -1]
              lowercase		:Optional[int]       							=				image_from_tuple[0, -3:, -3:, -1]

              assert image.shape == (1, 6_4, 6_4, 3)
              lowercase		:Dict       							=				np.array([0.51_25, 0.57_16, 0.48_28, 0.50_60, 0.56_50, 0.47_68, 0.51_85, 0.48_95, 0.49_93]				)

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






       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              lowercase		:List[str]       							=				StableDiffusionPipeline.from_pretrained(
                  '''hf-internal-testing/tiny-stable-diffusion-lms-pipe'''  ,     safety_checker=snake_case__				)
              assert isinstance(snake_case__  ,     snake_case__				)
              assert isinstance(pipe.scheduler  ,     snake_case__				)
              assert pipe.safety_checker is None

              lowercase		:Optional[Any]       							=				pipe('''example prompt'''  ,     num_inference_steps=2				).images[0]
              assert image is not None

              # check that there's no error when saving a pipeline with one of the models being None
              with tempfile.TemporaryDirectory() as tmpdirname:
                     pipe.save_pretrained(snake_case__				)
                     lowercase		:Dict       							=				StableDiffusionPipeline.from_pretrained(snake_case__				)

              # sanity check that the pipeline still works
              assert pipe.safety_checker is None
              lowercase		:Optional[Any]       							=				pipe('''example prompt'''  ,     num_inference_steps=2				).images[0]
              assert image is not None







       @unittest.skipIf(torch_device != '''cuda'''  ,     '''This test requires a GPU'''				)
       def  __snake_case						(   self  :    Optional[int]				):

              '''simple docstring'''






              lowercase		:List[Any]       							=				self.dummy_cond_unet
              lowercase		:Optional[int]       							=				PNDMScheduler(skip_prk_steps=snake_case__				)
              lowercase		:str       							=				self.dummy_vae
              lowercase		:Any       							=				self.dummy_text_encoder
              lowercase		:Optional[Any]       							=				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				)

              # put models in fp16
              lowercase		:Tuple       							=				unet.half()
              lowercase		:Optional[Any]       							=				vae.half()
              lowercase		:str       							=				bert.half()

              # make sure here that pndm scheduler skips prk
              lowercase		:Optional[int]       							=				StableDiffusionPipeline(
                  unet=snake_case__  ,     scheduler=snake_case__  ,     vae=snake_case__  ,     text_encoder=snake_case__  ,     tokenizer=snake_case__  ,     safety_checker=snake_case__  ,     feature_extractor=self.dummy_extractor  ,     )
              lowercase		:Any       							=				sd_pipe.to(snake_case__				)
              sd_pipe.set_progress_bar_config(disable=snake_case__				)

              lowercase		:Tuple       							=				'''A painting of a squirrel eating a burger'''
              lowercase		:List[str]       							=				sd_pipe([prompt]  ,     num_inference_steps=2  ,     output_type='''np'''				).images

              assert image.shape == (1, 6_4, 6_4, 3)







@nightly
@require_torch_gpu
class 					__magic_name__		(			unittest.TestCase     ):






       def  __snake_case						(   self  :    Tuple				):

              '''simple docstring'''






              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()






       def  __snake_case						(   self  :    Optional[int]				):

              '''simple docstring'''






              lowercase		:Optional[int]       							=				StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''  ,     safety_checker=snake_case__				)
              lowercase		:int       							=				LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config				)
              lowercase		:int       							=				sd_pipe.to(snake_case__				)
              sd_pipe.set_progress_bar_config(disable=snake_case__				)

              lowercase		:int       							=				(
                  '''portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle'''
                  ''' coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with'''
                  ''' anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and'''
                  ''' children from bahnhof zoo, detailed '''
              )
              lowercase		:Dict       							=				4_0_0_3_6_6_0_3_4_6
              lowercase		:Union[str, Any]       							=				7

              # without safety guidance (sld_guidance_scale = 0)
              lowercase		:List[Any]       							=				torch.manual_seed(snake_case__				)
              lowercase		:Optional[Any]       							=				sd_pipe(
                  [prompt]  ,     generator=snake_case__  ,     guidance_scale=snake_case__  ,     num_inference_steps=5_0  ,     output_type='''np'''  ,     width=5_1_2  ,     height=5_1_2  ,     sld_guidance_scale=0  ,     )

              lowercase		:str       							=				output.images
              lowercase		:Dict       							=				image[0, -3:, -3:, -1]
              lowercase		:List[Any]       							=				[0.22_78, 0.22_31, 0.22_49, 0.23_33, 0.23_03, 0.18_85, 0.22_73, 0.21_44, 0.21_76]

              assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

              # without safety guidance (strong configuration)
              lowercase		:Optional[Any]       							=				torch.manual_seed(snake_case__				)
              lowercase		:Optional[int]       							=				sd_pipe(
                  [prompt]  ,     generator=snake_case__  ,     guidance_scale=snake_case__  ,     num_inference_steps=5_0  ,     output_type='''np'''  ,     width=5_1_2  ,     height=5_1_2  ,     sld_guidance_scale=2_0_0_0  ,     sld_warmup_steps=7  ,     sld_threshold=0.0_25  ,     sld_momentum_scale=0.5  ,     sld_mom_beta=0.7  ,     )

              lowercase		:int       							=				output.images
              lowercase		:List[Any]       							=				image[0, -3:, -3:, -1]
              lowercase		:Dict       							=				[0.23_83, 0.22_76, 0.2_36, 0.21_92, 0.21_86, 0.20_53, 0.19_71, 0.19_01, 0.17_19]

              assert image.shape == (1, 5_1_2, 5_1_2, 3)

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






       def  __snake_case						(   self  :    Optional[Any]				):

              '''simple docstring'''






              lowercase		:str       							=				StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''  ,     safety_checker=snake_case__				)
              lowercase		:Union[str, Any]       							=				LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config				)
              lowercase		:int       							=				sd_pipe.to(snake_case__				)
              sd_pipe.set_progress_bar_config(disable=snake_case__				)

              lowercase		:Tuple       							=				'''padme amidala taking a bath artwork, safe for work, no nudity'''
              lowercase		:List[str]       							=				2_7_3_4_9_7_1_7_5_5
              lowercase		:Union[str, Any]       							=				7

              lowercase		:Any       							=				torch.manual_seed(snake_case__				)
              lowercase		:Union[str, Any]       							=				sd_pipe(
                  [prompt]  ,     generator=snake_case__  ,     guidance_scale=snake_case__  ,     num_inference_steps=5_0  ,     output_type='''np'''  ,     width=5_1_2  ,     height=5_1_2  ,     sld_guidance_scale=0  ,     )

              lowercase		:Dict       							=				output.images
              lowercase		:str       							=				image[0, -3:, -3:, -1]
              lowercase		:List[Any]       							=				[0.35_02, 0.36_22, 0.33_96, 0.36_42, 0.34_78, 0.33_18, 0.35, 0.33_48, 0.32_97]

              assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

              lowercase		:Optional[int]       							=				torch.manual_seed(snake_case__				)
              lowercase		:int       							=				sd_pipe(
                  [prompt]  ,     generator=snake_case__  ,     guidance_scale=snake_case__  ,     num_inference_steps=5_0  ,     output_type='''np'''  ,     width=5_1_2  ,     height=5_1_2  ,     sld_guidance_scale=2_0_0_0  ,     sld_warmup_steps=7  ,     sld_threshold=0.0_25  ,     sld_momentum_scale=0.5  ,     sld_mom_beta=0.7  ,     )

              lowercase		:Dict       							=				output.images
              lowercase		:str       							=				image[0, -3:, -3:, -1]
              lowercase		:str       							=				[0.55_31, 0.52_06, 0.48_95, 0.51_56, 0.51_82, 0.47_51, 0.48_02, 0.48_03, 0.44_43]

              assert image.shape == (1, 5_1_2, 5_1_2, 3)

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







       def  __snake_case						(   self  :    Optional[Any]				):

              '''simple docstring'''






              lowercase		:Optional[int]       							=				StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''				)
              lowercase		:str       							=				sd_pipe.to(snake_case__				)
              sd_pipe.set_progress_bar_config(disable=snake_case__				)

              lowercase		:Tuple       							=				(
                  '''the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c.'''
                  ''' leyendecker'''
              )
              lowercase		:int       							=				1_0_4_4_3_5_5_2_3_4
              lowercase		:int       							=				1_2

              lowercase		:int       							=				torch.manual_seed(snake_case__				)
              lowercase		:List[str]       							=				sd_pipe(
                  [prompt]  ,     generator=snake_case__  ,     guidance_scale=snake_case__  ,     num_inference_steps=5_0  ,     output_type='''np'''  ,     width=5_1_2  ,     height=5_1_2  ,     sld_guidance_scale=0  ,     )

              lowercase		:str       							=				output.images
              lowercase		:Optional[int]       							=				image[0, -3:, -3:, -1]
              lowercase		:Tuple       							=				np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]				)

              assert image.shape == (1, 5_1_2, 5_1_2, 3)

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

              lowercase		:Union[str, Any]       							=				torch.manual_seed(snake_case__				)
              lowercase		:Tuple       							=				sd_pipe(
                  [prompt]  ,     generator=snake_case__  ,     guidance_scale=snake_case__  ,     num_inference_steps=5_0  ,     output_type='''np'''  ,     width=5_1_2  ,     height=5_1_2  ,     sld_guidance_scale=2_0_0_0  ,     sld_warmup_steps=7  ,     sld_threshold=0.0_25  ,     sld_momentum_scale=0.5  ,     sld_mom_beta=0.7  ,     )

              lowercase		:List[str]       							=				output.images
              lowercase		:Optional[int]       							=				image[0, -3:, -3:, -1]
              lowercase		:str       							=				np.array([0.58_18, 0.62_85, 0.68_35, 0.60_19, 0.6_25, 0.67_54, 0.60_96, 0.63_34, 0.65_61]				)
              assert image.shape == (1, 5_1_2, 5_1_2, 3)

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





"""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 					__magic_name__		(			unittest.TestCase     ):
       __A			:      int        =   MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
       __A			:      List[str]        =   TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

       if model_mapping is not None:
              __A			:      int        =   {config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
       if tf_model_mapping is not None:
              __A			:      Optional[int]        =   {
                  config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
              }






       def  __snake_case						(   self  :    Tuple  ,     snake_case__  :    Any  ,     snake_case__  :    Union[str, Any]  ,     snake_case__  :    int				):

              '''simple docstring'''






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






       def  __snake_case						(   self  :    Any  ,     snake_case__  :    Union[str, Any]  ,     snake_case__  :    Tuple				):

              '''simple docstring'''






              lowercase		:int       							=				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
              lowercase		:Tuple       							=				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__				)]}				)

              lowercase		:Tuple       							=				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__				)]}				)

              lowercase		:Union[str, Any]       							=				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				)

              lowercase		:Optional[Any]       							=				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				)

              lowercase		:Optional[Any]       							=				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
              lowercase		:Optional[Any]       							=				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				)
                  ]  ,     )
              lowercase		: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  __snake_case						(   self  :    Any  ,     snake_case__  :    Pipeline				):

              '''simple docstring'''






              lowercase		:List[Any]       							=				zero_shot_classifier.model.config
              lowercase		:int       							=				config.labelaid
              lowercase		:str       							=				zero_shot_classifier.entailment_id

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

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

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

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

              lowercase		:Optional[Any]       							=				original_labelaid
              self.assertEqual(snake_case__  ,     zero_shot_classifier.entailment_id				)






       @require_torch
       def  __snake_case						(   self  :    List[str]				):

              '''simple docstring'''






              lowercase		: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  __snake_case						(   self  :    Union[str, Any]				):

              '''simple docstring'''






              lowercase		:str       							=				pipeline(
                  '''zero-shot-classification'''  ,     model='''sshleifer/tiny-distilbert-base-cased-distilled-squad'''  ,     framework='''pt'''  ,     )
              lowercase		: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],
                  }  ,     )






       @require_tf
       def  __snake_case						(   self  :    List[str]				):

              '''simple docstring'''






              lowercase		:Tuple       							=				pipeline(
                  '''zero-shot-classification'''  ,     model='''sshleifer/tiny-distilbert-base-cased-distilled-squad'''  ,     framework='''tf'''  ,     )
              lowercase		:List[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  __snake_case						(   self  :    Optional[int]				):

              '''simple docstring'''






              lowercase		:Dict       							=				pipeline('''zero-shot-classification'''  ,     model='''roberta-large-mnli'''  ,     framework='''pt'''				)
              lowercase		:Union[str, 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''': ['''politics''', '''public health''', '''science'''],
                      '''scores''': [0.9_76, 0.0_15, 0.0_09],
                  }  ,     )
              lowercase		:Optional[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],
                  }  ,     )







       @slow
       @require_tf
       def  __snake_case						(   self  :    Any				):

              '''simple docstring'''






              lowercase		:str       							=				pipeline('''zero-shot-classification'''  ,     model='''roberta-large-mnli'''  ,     framework='''tf'''				)
              lowercase		:Optional[int]       							=				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],
                  }  ,     )
              lowercase		:str       							=				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],
                  }  ,     )

