




'''simple docstring'''







import gc
import unittest

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

from diffusers import PriorTransformer, UnCLIPPipeline, UnCLIPScheduler, UNetaDConditionModel, UNetaDModel
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()


class       _a  (     __lowerCamelCase							,							unittest.TestCase			):
       __a    :					int           = UnCLIPPipeline
       __a    :					int           = TEXT_TO_IMAGE_PARAMS - {
           "negative_prompt",
           "height",
           "width",
           "negative_prompt_embeds",
           "guidance_scale",
           "prompt_embeds",
           "cross_attention_kwargs",
       }
       __a    :					Union[str, Any]           = TEXT_TO_IMAGE_BATCH_PARAMS
       __a    :					Optional[int]           = [
           "generator",
           "return_dict",
           "prior_num_inference_steps",
           "decoder_num_inference_steps",
           "super_res_num_inference_steps",
       ]
       __a    :					List[str]           = False
       @property
       def    A				(     self						:     List[Any]    ):



           '''simple docstring'''

           return 32
       @property
       def    A				(     self						:     Tuple    ):



           '''simple docstring'''

           return 32
       @property
       def    A				(     self						:     Union[str, Any]    ):



           '''simple docstring'''

           return self.time_input_dim
       @property
       def    A				(     self						:     Optional[Any]    ):



           '''simple docstring'''

           return self.time_input_dim * 4
       @property
       def    A				(     self						:     Any    ):



           '''simple docstring'''

           return 100
       @property
       def    A				(     self						:     int    ):



           '''simple docstring'''

           UpperCAmelCase      	=		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )
           return tokenizer
       @property
       def    A				(     self						:     Union[str, Any]    ):



           '''simple docstring'''

           torch.manual_seed(0    )
           UpperCAmelCase      	=		CLIPTextConfig(
               bos_token_id=0       ,    eos_token_id=2       ,    hidden_size=self.text_embedder_hidden_size       ,    projection_dim=self.text_embedder_hidden_size       ,    intermediate_size=37       ,    layer_norm_eps=1E-05       ,    num_attention_heads=4       ,    num_hidden_layers=5       ,    pad_token_id=1       ,    vocab_size=1_000       ,    )
           return CLIPTextModelWithProjection(_UpperCamelCase    )
       @property
       def    A				(     self						:     Optional[int]    ):



           '''simple docstring'''

           torch.manual_seed(0    )

           UpperCAmelCase      	=		{
               '''num_attention_heads''': 2,
               '''attention_head_dim''': 12,
               '''embedding_dim''': self.text_embedder_hidden_size,
               '''num_layers''': 1,
           }

           UpperCAmelCase      	=		PriorTransformer(**_UpperCamelCase    )
           return model
       @property
       def    A				(     self						:     List[str]    ):



           '''simple docstring'''

           torch.manual_seed(0    )

           UpperCAmelCase      	=		{
               '''clip_embeddings_dim''': self.text_embedder_hidden_size,
               '''time_embed_dim''': self.time_embed_dim,
               '''cross_attention_dim''': self.cross_attention_dim,
           }

           UpperCAmelCase      	=		UnCLIPTextProjModel(**_UpperCamelCase    )
           return model
       @property
       def    A				(     self						:     List[Any]    ):



           '''simple docstring'''

           torch.manual_seed(0    )

           UpperCAmelCase      	=		{
               '''sample_size''': 32,
               # RGB in channels
               '''in_channels''': 3,
               # Out channels is double in channels because predicts mean and variance
               '''out_channels''': 6,
               '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
               '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
               '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
               '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
               '''layers_per_block''': 1,
               '''cross_attention_dim''': self.cross_attention_dim,
               '''attention_head_dim''': 4,
               '''resnet_time_scale_shift''': '''scale_shift''',
               '''class_embed_type''': '''identity''',
           }

           UpperCAmelCase      	=		UNetaDConditionModel(**_UpperCamelCase    )
           return model
       @property
       def    A				(     self						:     Tuple    ):



           '''simple docstring'''

           return {
               "sample_size": 64,
               "layers_per_block": 1,
               "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
               "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
               "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
               "in_channels": 6,
               "out_channels": 3,
           }
       @property
       def    A				(     self						:     int    ):



           '''simple docstring'''

           torch.manual_seed(0    )

           UpperCAmelCase      	=		UNetaDModel(**self.dummy_super_res_kwargs    )
           return model
       @property
       def    A				(     self						:     Union[str, Any]    ):



           '''simple docstring'''

           torch.manual_seed(1    )

           UpperCAmelCase      	=		UNetaDModel(**self.dummy_super_res_kwargs    )
           return model
       def    A				(     self						:     Optional[int]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.dummy_prior
           UpperCAmelCase      	=		self.dummy_decoder
           UpperCAmelCase      	=		self.dummy_text_proj
           UpperCAmelCase      	=		self.dummy_text_encoder
           UpperCAmelCase      	=		self.dummy_tokenizer
           UpperCAmelCase      	=		self.dummy_super_res_first
           UpperCAmelCase      	=		self.dummy_super_res_last

           UpperCAmelCase      	=		UnCLIPScheduler(
               variance_type='''fixed_small_log'''       ,    prediction_type='''sample'''       ,    num_train_timesteps=1_000       ,    clip_sample_range=5.0       ,    )

           UpperCAmelCase      	=		UnCLIPScheduler(
               variance_type='''learned_range'''       ,    prediction_type='''epsilon'''       ,    num_train_timesteps=1_000       ,    )

           UpperCAmelCase      	=		UnCLIPScheduler(
               variance_type='''fixed_small_log'''       ,    prediction_type='''epsilon'''       ,    num_train_timesteps=1_000       ,    )

           UpperCAmelCase      	=		{
               '''prior''': prior,
               '''decoder''': decoder,
               '''text_proj''': text_proj,
               '''text_encoder''': text_encoder,
               '''tokenizer''': tokenizer,
               '''super_res_first''': super_res_first,
               '''super_res_last''': super_res_last,
               '''prior_scheduler''': prior_scheduler,
               '''decoder_scheduler''': decoder_scheduler,
               '''super_res_scheduler''': super_res_scheduler,
           }

           return components
       def    A				(     self						:     str       ,    lowercase						:     Dict       ,    lowercase						:     int=0    ):



           '''simple docstring'''

           if str(_UpperCamelCase    ).startswith('''mps'''    ):
               UpperCAmelCase      	=		torch.manual_seed(_UpperCamelCase    )
           else:
               UpperCAmelCase      	=		torch.Generator(device=_UpperCamelCase    ).manual_seed(_UpperCamelCase    )
           UpperCAmelCase      	=		{
               '''prompt''': '''horse''',
               '''generator''': generator,
               '''prior_num_inference_steps''': 2,
               '''decoder_num_inference_steps''': 2,
               '''super_res_num_inference_steps''': 2,
               '''output_type''': '''numpy''',
           }
           return inputs
       def    A				(     self						:     List[Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		'''cpu'''

           UpperCAmelCase      	=		self.get_dummy_components()

           UpperCAmelCase      	=		self.pipeline_class(**_UpperCamelCase    )
           UpperCAmelCase      	=		pipe.to(_UpperCamelCase    )

           pipe.set_progress_bar_config(disable=_UpperCamelCase    )

           UpperCAmelCase      	=		pipe(**self.get_dummy_inputs(_UpperCamelCase    )    )
           UpperCAmelCase      	=		output.images

           UpperCAmelCase      	=		pipe(
               **self.get_dummy_inputs(_UpperCamelCase    )       ,    return_dict=_UpperCamelCase       ,    )[0]

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

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

           UpperCAmelCase      	=		np.array(
               [
                   0.9997,
                   0.9988,
                   0.0028,
                   0.9997,
                   0.9984,
                   0.9965,
                   0.0029,
                   0.9986,
                   0.0025,
               ]    )

           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    A				(     self						:     Any    ):



           '''simple docstring'''

           UpperCAmelCase      	=		torch.device('''cpu'''    )


           class       _a  :
                  __a    :					int           = 1






           UpperCAmelCase      	=		self.get_dummy_components()

           UpperCAmelCase      	=		self.pipeline_class(**_UpperCamelCase    )
           UpperCAmelCase      	=		pipe.to(_UpperCamelCase    )

           UpperCAmelCase      	=		components['''prior''']
           UpperCAmelCase      	=		components['''decoder''']
           UpperCAmelCase      	=		components['''super_res_first''']
           UpperCAmelCase      	=		components['''tokenizer''']
           UpperCAmelCase      	=		components['''text_encoder''']

           UpperCAmelCase      	=		torch.Generator(device=_UpperCamelCase    ).manual_seed(0    )
           UpperCAmelCase      	=		prior.dtype
           UpperCAmelCase      	=		1

           UpperCAmelCase      	=		(batch_size, prior.config.embedding_dim)
           UpperCAmelCase      	=		pipe.prepare_latents(
               _UpperCamelCase       ,    dtype=_UpperCamelCase       ,    device=_UpperCamelCase       ,    generator=_UpperCamelCase       ,    latents=_UpperCamelCase       ,    scheduler=DummyScheduler()    )
           UpperCAmelCase      	=		(batch_size, decoder.config.in_channels, decoder.config.sample_size, decoder.config.sample_size)
           UpperCAmelCase      	=		pipe.prepare_latents(
               _UpperCamelCase       ,    dtype=_UpperCamelCase       ,    device=_UpperCamelCase       ,    generator=_UpperCamelCase       ,    latents=_UpperCamelCase       ,    scheduler=DummyScheduler()    )

           UpperCAmelCase      	=		(
               batch_size,
               super_res_first.config.in_channels // 2,
               super_res_first.config.sample_size,
               super_res_first.config.sample_size,
           )
           UpperCAmelCase      	=		pipe.prepare_latents(
               _UpperCamelCase       ,    dtype=_UpperCamelCase       ,    device=_UpperCamelCase       ,    generator=_UpperCamelCase       ,    latents=_UpperCamelCase       ,    scheduler=DummyScheduler()    )

           pipe.set_progress_bar_config(disable=_UpperCamelCase    )

           UpperCAmelCase      	=		'''this is a prompt example'''

           UpperCAmelCase      	=		torch.Generator(device=_UpperCamelCase    ).manual_seed(0    )
           UpperCAmelCase      	=		pipe(
               [prompt]       ,    generator=_UpperCamelCase       ,    prior_num_inference_steps=2       ,    decoder_num_inference_steps=2       ,    super_res_num_inference_steps=2       ,    prior_latents=_UpperCamelCase       ,    decoder_latents=_UpperCamelCase       ,    super_res_latents=_UpperCamelCase       ,    output_type='''np'''       ,    )
           UpperCAmelCase      	=		output.images

           UpperCAmelCase      	=		tokenizer(
               _UpperCamelCase       ,    padding='''max_length'''       ,    max_length=tokenizer.model_max_length       ,    return_tensors='''pt'''       ,    )
           UpperCAmelCase      	=		text_encoder(text_inputs.input_ids    )
           UpperCAmelCase      	=		text_inputs.attention_mask

           UpperCAmelCase      	=		torch.Generator(device=_UpperCamelCase    ).manual_seed(0    )
           UpperCAmelCase      	=		pipe(
               generator=_UpperCamelCase       ,    prior_num_inference_steps=2       ,    decoder_num_inference_steps=2       ,    super_res_num_inference_steps=2       ,    prior_latents=_UpperCamelCase       ,    decoder_latents=_UpperCamelCase       ,    super_res_latents=_UpperCamelCase       ,    text_model_output=_UpperCamelCase       ,    text_attention_mask=_UpperCamelCase       ,    output_type='''np'''       ,    )[0]

           # make sure passing text embeddings manually is identical
           assert np.abs(image - image_from_text    ).max() < 1E-4
       @skip_mps
       def    A				(     self						:     List[Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		torch_device == '''cpu'''

           self._test_attention_slicing_forward_pass(test_max_difference=_UpperCamelCase       ,    expected_max_diff=0.01    )
       @skip_mps
       def    A				(     self						:     Any    ):



           '''simple docstring'''

           UpperCAmelCase      	=		torch_device == '''cpu'''
           UpperCAmelCase      	=		True
           UpperCAmelCase      	=		[
               '''prior_num_inference_steps''',
               '''decoder_num_inference_steps''',
               '''super_res_num_inference_steps''',
           ]

           self._test_inference_batch_single_identical(
               test_max_difference=_UpperCamelCase       ,    relax_max_difference=_UpperCamelCase       ,    additional_params_copy_to_batched_inputs=_UpperCamelCase       ,    )
       def    A				(     self						:     Union[str, Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		[
               '''prior_num_inference_steps''',
               '''decoder_num_inference_steps''',
               '''super_res_num_inference_steps''',
           ]

           if torch_device == "mps":
               # TODO: MPS errors with larger batch sizes
               UpperCAmelCase      	=		[2, 3]
               self._test_inference_batch_consistent(
                   batch_sizes=_UpperCamelCase       ,    additional_params_copy_to_batched_inputs=_UpperCamelCase       ,    )
           else:
               self._test_inference_batch_consistent(
                   additional_params_copy_to_batched_inputs=_UpperCamelCase    )
       @skip_mps
       def    A				(     self						:     Union[str, Any]    ):



           '''simple docstring'''

           return super().test_dict_tuple_outputs_equivalent()
       @skip_mps
       def    A				(     self						:     int    ):



           '''simple docstring'''

           return super().test_save_load_local()







       @skip_mps
       def    A				(     self						:     List[Any]    ):



           '''simple docstring'''

           return super().test_save_load_optional_components()






@nightly
class       _a  (     unittest.TestCase			):
       def    A				(     self						:     Union[str, Any]    ):



           '''simple docstring'''

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







       def    A				(     self						:     List[Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		load_numpy(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
               '''/unclip/karlo_v1_alpha_horse_cpu.npy'''    )

           UpperCAmelCase      	=		UnCLIPPipeline.from_pretrained('''kakaobrain/karlo-v1-alpha'''    )
           pipeline.set_progress_bar_config(disable=_UpperCamelCase    )

           UpperCAmelCase      	=		torch.manual_seed(0    )
           UpperCAmelCase      	=		pipeline(
               '''horse'''       ,    num_images_per_prompt=1       ,    generator=_UpperCamelCase       ,    output_type='''np'''       ,    )

           UpperCAmelCase      	=		output.images[0]

           assert image.shape == (256, 256, 3)
           assert np.abs(expected_image - image    ).max() < 1E-1






@slow
@require_torch_gpu
class       _a  (     unittest.TestCase			):
       def    A				(     self						:     List[Any]    ):



           '''simple docstring'''

           super().tearDown()
           gc.collect()
           torch.cuda.empty_cache()
       def    A				(     self						:     Optional[Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		load_numpy(
               '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
               '''/unclip/karlo_v1_alpha_horse_fp16.npy'''    )

           UpperCAmelCase      	=		UnCLIPPipeline.from_pretrained('''kakaobrain/karlo-v1-alpha'''       ,    torch_dtype=torch.floataa    )
           UpperCAmelCase      	=		pipeline.to(_UpperCamelCase    )
           pipeline.set_progress_bar_config(disable=_UpperCamelCase    )

           UpperCAmelCase      	=		torch.Generator(device='''cpu'''    ).manual_seed(0    )
           UpperCAmelCase      	=		pipeline(
               '''horse'''       ,    generator=_UpperCamelCase       ,    output_type='''np'''       ,    )

           UpperCAmelCase      	=		output.images[0]

           assert image.shape == (256, 256, 3)

           assert_mean_pixel_difference(_UpperCamelCase       ,    _UpperCamelCase    )







       def    A				(     self						:     str    ):



           '''simple docstring'''

           torch.cuda.empty_cache()
           torch.cuda.reset_max_memory_allocated()
           torch.cuda.reset_peak_memory_stats()

           UpperCAmelCase      	=		UnCLIPPipeline.from_pretrained('''kakaobrain/karlo-v1-alpha'''       ,    torch_dtype=torch.floataa    )
           UpperCAmelCase      	=		pipe.to(_UpperCamelCase    )
           pipe.set_progress_bar_config(disable=_UpperCamelCase    )
           pipe.enable_attention_slicing()
           pipe.enable_sequential_cpu_offload()

           UpperCAmelCase      	=		pipe(
               '''horse'''       ,    num_images_per_prompt=1       ,    prior_num_inference_steps=2       ,    decoder_num_inference_steps=2       ,    super_res_num_inference_steps=2       ,    output_type='''np'''       ,    )

           UpperCAmelCase      	=		torch.cuda.max_memory_allocated()
           # make sure that less than 7 GB is allocated
           assert mem_bytes < 7 * 10**9











'''simple docstring'''







import subprocess
from typing import Union

import numpy as np
import requests

from ..utils import add_end_docstrings, is_torch_available, is_torchaudio_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_torch_available():
   from ..models.auto.modeling_auto import MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING

A			   =logging.get_logger(__name__)





def 						snake_case_							(_a     :							bytes   ,       _a     :							int					):
    UpperCAmelCase      	=		F"{sampling_rate}"
    UpperCAmelCase      	=		'''1'''
    UpperCAmelCase      	=		'''f32le'''
    UpperCAmelCase      	=		[
        '''ffmpeg''',
        '''-i''',
        '''pipe:0''',
        '''-ac''',
        ac,
        '''-ar''',
        ar,
        '''-f''',
        format_for_conversion,
        '''-hide_banner''',
        '''-loglevel''',
        '''quiet''',
        '''pipe:1''',
    ]

    try:
        UpperCAmelCase      	=		subprocess.Popen(_a   ,       stdin=subprocess.PIPE   ,       stdout=subprocess.PIPE					)
    except FileNotFoundError:
        raise ValueError('''ffmpeg was not found but is required to load audio files from filename'''					)
    UpperCAmelCase      	=		ffmpeg_process.communicate(_a					)
    UpperCAmelCase      	=		output_stream[0]

    UpperCAmelCase      	=		np.frombuffer(_a   ,       np.floataa					)
    if audio.shape[0] == 0:
        raise ValueError('''Malformed soundfile'''					)
    return audio







@add_end_docstrings(__a			)
class       _a  (     __a			):
       def __init__(     self						:     Dict       ,    *lowercase						:     Dict       ,    **lowercase						:     Any    ):



           '''simple docstring'''

           UpperCAmelCase      	=		5
           super().__init__(*lowercase       ,    **lowercase    )

           if self.framework != "pt":
               raise ValueError(f"The {self.__class__} is only available in PyTorch."    )

           self.check_model_type(lowercase    )
       def __call__(     self						:     List[Any]       ,    lowercase						:     Union[np.ndarray, bytes, str]       ,    **lowercase						:     Dict       ,    ):



           '''simple docstring'''

           return super().__call__(lowercase       ,    **lowercase    )
       def    A				(     self						:     Tuple       ,    lowercase						:     Dict=None       ,    **lowercase						:     List[str]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		{}
           if top_k is not None:
               if top_k > self.model.config.num_labels:
                   UpperCAmelCase      	=		self.model.config.num_labels
               UpperCAmelCase      	=		top_k
           return {}, {}, postprocess_params
       def    A				(     self						:     List[Any]       ,    lowercase						:     Union[str, Any]    ):



           '''simple docstring'''

           if isinstance(lowercase       ,    lowercase    ):
               if inputs.startswith('''http://'''    ) or inputs.startswith('''https://'''    ):
                   # We need to actually check for a real protocol, otherwise it's impossible to use a local file
                   # like http_huggingface_co.png
                   UpperCAmelCase      	=		requests.get(lowercase    ).content
               else:
                   with open(lowercase       ,    '''rb'''    ) as f:
                       UpperCAmelCase      	=		f.read()

           if isinstance(lowercase       ,    lowercase    ):
               UpperCAmelCase      	=		ffmpeg_read(lowercase       ,    self.feature_extractor.sampling_rate    )

           if isinstance(lowercase       ,    lowercase    ):
               # Accepting `"array"` which is the key defined in `datasets` for
               # better integration
               if not ("sampling_rate" in inputs and ("raw" in inputs or "array" in inputs)):
                   raise ValueError(
                       '''When passing a dictionary to AudioClassificationPipeline, the dict needs to contain a '''
                       '''"raw" key containing the numpy array representing the audio and a "sampling_rate" key, '''
                       '''containing the sampling_rate associated with that array'''    )

               UpperCAmelCase      	=		inputs.pop('''raw'''       ,    lowercase    )
               if _inputs is None:
                   # Remove path which will not be used from `datasets`.
                   inputs.pop('''path'''       ,    lowercase    )
                   UpperCAmelCase      	=		inputs.pop('''array'''       ,    lowercase    )
               UpperCAmelCase      	=		inputs.pop('''sampling_rate'''    )
               UpperCAmelCase      	=		_inputs
               if in_sampling_rate != self.feature_extractor.sampling_rate:
                   import torch

                   if is_torchaudio_available():
                       from torchaudio import functional as F
                   else:
                       raise ImportError(
                           '''torchaudio is required to resample audio samples in AudioClassificationPipeline. '''
                           '''The torchaudio package can be installed through: `pip install torchaudio`.'''    )

                   UpperCAmelCase      	=		F.resample(
                       torch.from_numpy(lowercase    )       ,    lowercase       ,    self.feature_extractor.sampling_rate    ).numpy()

           if not isinstance(lowercase       ,    np.ndarray    ):
               raise ValueError('''We expect a numpy ndarray as input'''    )
           if len(inputs.shape    ) != 1:
               raise ValueError('''We expect a single channel audio input for AudioClassificationPipeline'''    )

           UpperCAmelCase      	=		self.feature_extractor(
               lowercase       ,    sampling_rate=self.feature_extractor.sampling_rate       ,    return_tensors='''pt'''    )
           return processed
       def    A				(     self						:     Optional[Any]       ,    lowercase						:     List[str]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.model(**lowercase    )
           return model_outputs







       def    A				(     self						:     Union[str, Any]       ,    lowercase						:     Optional[Any]       ,    lowercase						:     List[str]=5    ):



           '''simple docstring'''

           UpperCAmelCase      	=		model_outputs.logits[0].softmax(-1    )
           UpperCAmelCase	,					UpperCAmelCase      	=		probs.topk(lowercase    )

           UpperCAmelCase      	=		scores.tolist()
           UpperCAmelCase      	=		ids.tolist()

           UpperCAmelCase      	=		[{'''score''': score, '''label''': self.model.config.idalabel[_id]} for score, _id in zip(lowercase       ,    lowercase    )]

           return labels




