
"""simple docstring"""





import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TextClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
_a		       =							{'LayoutLMv2Config', 'LayoutLMv3Config'}


@is_pipeline_test
class A_	(unittest.TestCase      ):




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__			:						int       =		MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
  SCREAMING_SNAKE_CASE__			:						Optional[Any]       =		TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

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







  @require_torch
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Union[str, Any]			     =    pipeline(
         task="text-classification"				,   model="hf-internal-testing/tiny-random-distilbert"				,   framework="pt"  )

     UpperCAmelCase_					:					Dict			     =    text_classifier("This is great !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "LABEL_0", "score": 0.5_04}]  )

     UpperCAmelCase_					:					Dict			     =    text_classifier("This is great !"				,   top_k=2  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   [{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}]  )

     UpperCAmelCase_					:					int			     =    text_classifier(["This is great !", "This is bad"]				,   top_k=2  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   [
             [{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}],
             [{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}],
         ]				,   )

     UpperCAmelCase_					:					List[Any]			     =    text_classifier("This is great !"				,   top_k=1  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "LABEL_0", "score": 0.5_04}]  )

     # Legacy behavior
     UpperCAmelCase_					:					Union[str, Any]			     =    text_classifier("This is great !"				,   return_all_scores=lowercase_  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "LABEL_0", "score": 0.5_04}]  )

     UpperCAmelCase_					:					Optional[Any]			     =    text_classifier("This is great !"				,   return_all_scores=lowercase_  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   [[{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}]]  )

     UpperCAmelCase_					:					Optional[int]			     =    text_classifier(["This is great !", "Something else"]				,   return_all_scores=lowercase_  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   [
             [{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}],
             [{"label": "LABEL_0", "score": 0.5_04}, {"label": "LABEL_1", "score": 0.4_96}],
         ]				,   )

     UpperCAmelCase_					:					Optional[int]			     =    text_classifier(["This is great !", "Something else"]				,   return_all_scores=lowercase_  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   [
             {"label": "LABEL_0", "score": 0.5_04},
             {"label": "LABEL_0", "score": 0.5_04},
         ]				,   )







  @require_torch
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     import torch

     UpperCAmelCase_					:					Optional[Any]			     =    pipeline(
         task="text-classification"				,   model="hf-internal-testing/tiny-random-distilbert"				,   framework="pt"				,   device=torch.device("cpu"  )				,   )

     UpperCAmelCase_					:					Dict			     =    text_classifier("This is great !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "LABEL_0", "score": 0.5_04}]  )







  @require_tf
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[Any]			     =    pipeline(
         task="text-classification"				,   model="hf-internal-testing/tiny-random-distilbert"				,   framework="tf"  )

     UpperCAmelCase_					:					Optional[Any]			     =    text_classifier("This is great !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "LABEL_0", "score": 0.5_04}]  )







  @slow
  @require_torch
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Any			     =    pipeline("text-classification"  )

     UpperCAmelCase_					:					Tuple			     =    text_classifier("This is great !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "POSITIVE", "score": 1.0}]  )
     UpperCAmelCase_					:					int			     =    text_classifier("This is bad !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "NEGATIVE", "score": 1.0}]  )
     UpperCAmelCase_					:					Optional[Any]			     =    text_classifier("Birds are a type of animal"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "POSITIVE", "score": 0.9_88}]  )







  @slow
  @require_tf
  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[int]			     =    pipeline("text-classification"				,   framework="tf"  )

     UpperCAmelCase_					:					int			     =    text_classifier("This is great !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "POSITIVE", "score": 1.0}]  )
     UpperCAmelCase_					:					List[Any]			     =    text_classifier("This is bad !"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "NEGATIVE", "score": 1.0}]  )
     UpperCAmelCase_					:					Union[str, Any]			     =    text_classifier("Birds are a type of animal"  )
     self.assertEqual(nested_simplify(lowercase_  )				,   [{"label": "POSITIVE", "score": 0.9_88}]  )







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					Any			     =    TextClassificationPipeline(model=lowercase_				,   tokenizer=lowercase_  )
     return text_classifier, ["HuggingFace is in", "This is another test"]







  def        UpperCamelCase__					(		self				,   lowercase_				,   lowercase_  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[Any]			     =    text_classifier.model
     # Small inputs because BartTokenizer tiny has maximum position embeddings = 22
     UpperCAmelCase_					:					str			     =    "HuggingFace is in"
     UpperCAmelCase_					:					Dict			     =    text_classifier(lowercase_  )

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

     UpperCAmelCase_					:					Any			     =    ["HuggingFace is in ", "Paris is in France"]
     UpperCAmelCase_					:					List[Any]			     =    text_classifier(lowercase_  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   [{"label": ANY(lowercase_  ), "score": ANY(lowercase_  )}, {"label": ANY(lowercase_  ), "score": ANY(lowercase_  )}]				,   )
     self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()  )
     self.assertTrue(outputs[1]["label"] in model.config.idalabel.values()  )

     # Forcing to get all results with `top_k=None`
     # This is NOT the legacy format
     UpperCAmelCase_					:					Optional[int]			     =    text_classifier(lowercase_				,   top_k=lowercase_  )
     UpperCAmelCase_					:					int			     =    len(model.config.idalabel.values()  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   [[{"label": ANY(lowercase_  ), "score": ANY(lowercase_  )}] * N, [{"label": ANY(lowercase_  ), "score": ANY(lowercase_  )}] * N]				,   )

     UpperCAmelCase_					:					List[Any]			     =    {"text": "HuggingFace is in ", "text_pair": "Paris is in France"}
     UpperCAmelCase_					:					int			     =    text_classifier(lowercase_  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   {"label": ANY(lowercase_  ), "score": ANY(lowercase_  )}				,   )
     self.assertTrue(outputs["label"] in model.config.idalabel.values()  )

     # This might be used a text pair, but tokenizer + pipe interaction
     # makes it hard to understand that it's not using the pair properly
     # https://github.com/huggingface/transformers/issues/17305
     # We disabled this usage instead as it was outputting wrong outputs.
     UpperCAmelCase_					:					Dict			     =    [["HuggingFace is in ", "Paris is in France"]]
     with self.assertRaises(lowercase_  ):
        text_classifier(lowercase_  )

     # This used to be valid for doing text pairs
     # We're keeping it working because of backward compatibility
     UpperCAmelCase_					:					Optional[int]			     =    text_classifier([[["HuggingFace is in ", "Paris is in France"]]]  )
     self.assertEqual(
         nested_simplify(lowercase_  )				,   [{"label": ANY(lowercase_  ), "score": ANY(lowercase_  )}]				,   )
     self.assertTrue(outputs[0]["label"] in model.config.idalabel.values()  )




import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizer

from diffusers import (
    AltDiffusionImgaImgPipeline,
    AutoencoderKL,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.image_processor import VaeImageProcessor
from diffusers.pipelines.alt_diffusion.modeling_roberta_series import (
    RobertaSeriesConfig,
    RobertaSeriesModelWithTransformation,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()







class 				lowercase		(					unittest.TestCase		):




							def  A__      (				self):
												# clean up the VRAM after each test
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()




							@property
							def  A__      (				self):
												lowercase							=						1
												lowercase							=						3
												lowercase							=						(3_2, 3_2)

												lowercase							=						floats_tensor((batch_size, num_channels) + sizes   ,rng=random.Random(0)).to(A__)
												return image




							@property
							def  A__      (				self):
												torch.manual_seed(0)
												lowercase							=						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  A__      (				self):
												torch.manual_seed(0)
												lowercase							=						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  A__      (				self):
												torch.manual_seed(0)
												lowercase							=						RobertaSeriesConfig(
												    hidden_size=3_2   ,project_dim=3_2   ,intermediate_size=3_7   ,layer_norm_eps=1E-05   ,num_attention_heads=4   ,num_hidden_layers=5   ,pad_token_id=1   ,vocab_size=5_0_0_6   ,)
												return RobertaSeriesModelWithTransformation(A__)




							@property
							def  A__      (				self):
												def extract(*A__   ,**A__):







																	class 				lowercase		:




																								def __init__(				self):
																													lowercase							=						torch.ones([0])





																								def  A__      (				self   ,A__):
																													self.pixel_values.to(A__)
																													return self


																	return Out()

												return extract




							def  A__      (				self):
												lowercase							=						'''cpu'''  # ensure determinism for the device-dependent torch.Generator
												lowercase							=						self.dummy_cond_unet
												lowercase							=						PNDMScheduler(skip_prk_steps=A__)
												lowercase							=						self.dummy_vae
												lowercase							=						self.dummy_text_encoder
												lowercase							=						XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta''')
												lowercase							=						7_7

												lowercase							=						self.dummy_image.to(A__)
												lowercase							=						init_image / 2 + 0.5

												# make sure here that pndm scheduler skips prk
												lowercase							=						AltDiffusionImgaImgPipeline(
												    unet=A__   ,scheduler=A__   ,vae=A__   ,text_encoder=A__   ,tokenizer=A__   ,safety_checker=A__   ,feature_extractor=self.dummy_extractor   ,)
												lowercase							=						VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor   ,do_normalize=A__)
												lowercase							=						alt_pipe.to(A__)
												alt_pipe.set_progress_bar_config(disable=A__)

												lowercase							=						'''A painting of a squirrel eating a burger'''
												lowercase							=						torch.Generator(device=A__).manual_seed(0)
												lowercase							=						alt_pipe(
												    [prompt]   ,generator=A__   ,guidance_scale=6.0   ,num_inference_steps=2   ,output_type='''np'''   ,image=A__   ,)

												lowercase							=						output.images

												lowercase							=						torch.Generator(device=A__).manual_seed(0)
												lowercase							=						alt_pipe(
												    [prompt]   ,generator=A__   ,guidance_scale=6.0   ,num_inference_steps=2   ,output_type='''np'''   ,image=A__   ,return_dict=A__   ,)[0]

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

												assert image.shape == (1, 3_2, 3_2, 3)
												lowercase							=						np.array([0.4427, 0.3731, 0.4249, 0.4941, 0.4546, 0.4148, 0.4193, 0.4666, 0.4499])

												assert np.abs(image_slice.flatten() - expected_slice).max() < 5E-3
												assert np.abs(image_from_tuple_slice.flatten() - expected_slice).max() < 5E-3




							@unittest.skipIf(torch_device != '''cuda'''   ,'''This test requires a GPU''')
							def  A__      (				self):
												lowercase							=						self.dummy_cond_unet
												lowercase							=						PNDMScheduler(skip_prk_steps=A__)
												lowercase							=						self.dummy_vae
												lowercase							=						self.dummy_text_encoder
												lowercase							=						XLMRobertaTokenizer.from_pretrained('''hf-internal-testing/tiny-xlm-roberta''')
												lowercase							=						7_7

												lowercase							=						self.dummy_image.to(A__)

												# put models in fp16
												lowercase							=						unet.half()
												lowercase							=						vae.half()
												lowercase							=						bert.half()

												# make sure here that pndm scheduler skips prk
												lowercase							=						AltDiffusionImgaImgPipeline(
												    unet=A__   ,scheduler=A__   ,vae=A__   ,text_encoder=A__   ,tokenizer=A__   ,safety_checker=A__   ,feature_extractor=self.dummy_extractor   ,)
												lowercase							=						VaeImageProcessor(vae_scale_factor=alt_pipe.vae_scale_factor   ,do_normalize=A__)
												lowercase							=						alt_pipe.to(A__)
												alt_pipe.set_progress_bar_config(disable=A__)

												lowercase							=						'''A painting of a squirrel eating a burger'''
												lowercase							=						torch.manual_seed(0)
												lowercase							=						alt_pipe(
												    [prompt]   ,generator=A__   ,num_inference_steps=2   ,output_type='''np'''   ,image=A__   ,).images

												assert image.shape == (1, 3_2, 3_2, 3)





							@unittest.skipIf(torch_device != '''cuda'''   ,'''This test requires a GPU''')
							def  A__      (				self):
												lowercase							=						load_image(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
												    '''/img2img/sketch-mountains-input.jpg''')
												# resize to resolution that is divisible by 8 but not 16 or 32
												lowercase							=						init_image.resize((7_6_0, 5_0_4))

												lowercase							=						'''BAAI/AltDiffusion'''
												lowercase							=						AltDiffusionImgaImgPipeline.from_pretrained(
												    A__   ,safety_checker=A__   ,)
												pipe.to(A__)
												pipe.set_progress_bar_config(disable=A__)
												pipe.enable_attention_slicing()

												lowercase							=						'''A fantasy landscape, trending on artstation'''

												lowercase							=						torch.manual_seed(0)
												lowercase							=						pipe(
												    prompt=A__   ,image=A__   ,strength=0.75   ,guidance_scale=7.5   ,generator=A__   ,output_type='''np'''   ,)
												lowercase							=						output.images[0]

												lowercase							=						image[2_5_5:2_5_8, 3_8_3:3_8_6, -1]

												assert image.shape == (5_0_4, 7_6_0, 3)
												lowercase							=						np.array([0.9358, 0.9397, 0.9599, 0.9901, 1.0000, 1.0000, 0.9882, 1.0000, 1.0000])

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







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




							def  A__      (				self):
												# clean up the VRAM after each test
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()





							def  A__      (				self):
												lowercase							=						load_image(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
												    '''/img2img/sketch-mountains-input.jpg''')
												lowercase							=						init_image.resize((7_6_8, 5_1_2))
												lowercase							=						load_numpy(
												    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/img2img/fantasy_landscape_alt.npy''')

												lowercase							=						'''BAAI/AltDiffusion'''
												lowercase							=						AltDiffusionImgaImgPipeline.from_pretrained(
												    A__   ,safety_checker=A__   ,)
												pipe.to(A__)
												pipe.set_progress_bar_config(disable=A__)
												pipe.enable_attention_slicing()

												lowercase							=						'''A fantasy landscape, trending on artstation'''

												lowercase							=						torch.manual_seed(0)
												lowercase							=						pipe(
												    prompt=A__   ,image=A__   ,strength=0.75   ,guidance_scale=7.5   ,generator=A__   ,output_type='''np'''   ,)
												lowercase							=						output.images[0]

												assert image.shape == (5_1_2, 7_6_8, 3)
												# img2img is flaky across GPUs even in fp32, so using MAE here
												assert np.abs(expected_image - image).max() < 1E-2




